mistral_translator 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 278978acb1df0d447293200f13ff58745640a62f5bf43a41ebc7b31db2d50b98
-  data.tar.gz: c86fc021d49a554fd4d44883e1383a5ea4ba82251074b4b358b3b5cf97f27fd2
+  metadata.gz: 9ecf7ff10300ed8793126b3417e1b26444daf4c6778ac13d95224880175cb96c
+  data.tar.gz: 5ade2f503013b9b539831e9dfddb830fdd68ca6e8a98762a1a0cd97f2d0d1f63
 SHA512:
-  metadata.gz: ca6e0c3b2e2346ab8432dfc24080adcb994f75df453111851d6f8441465d09107d59216fc84efc1f84acf823a4a4ec284c5d1b1212c8ceda9a3d8861e95a2208
-  data.tar.gz: 39b55072eb24870acd861b8c7ec7c8aa279a9f7b03b4a84f0cdabd4982c2d9f04da1b39b2eea05024d6e3a2c1bc7737ee95557f0eaa588c61ec3fbc5d04af540
+  metadata.gz: 23afe648e77f352c771231bee584b0a2cee50c1bf3a2c4c747bf24874a0aeca4c9304fd1f0c8e34cd732591d4551235258d0091a4624f82879235bab737708f2
+  data.tar.gz: cd5c9ab42a3369c70ac0d9716e263f25eaf38e7541c8dc18533b1c603db14d6d96c6e628c074bc13e9471ebd2e51b034e946432e8bdca0d0ed1d511fea9bc9cf

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-28
+
+### Changed
+
+These changes alter behaviour that callers may rely on:
+
+- Unusable responses now raise instead of being returned. A response without JSON, with a target that is not text, or with a blank target raises `InvalidResponseError` or `EmptyTranslationError` after the usual retries. Previously the raw response text could be stored as the translation or the summary.
+- `summarize_and_translate` no longer falls back to an untranslated summary in the source language; it retries like the other summaries, then raises.
+- `translate_auto` raises `InvalidResponseError` when language detection is unreadable or names an unsupported language. It used to assume English, which returned the source text untranslated when the target was English.
+- `PromptBuilder` methods return a `MistralTranslator::Prompt` (`instructions` and `text`) instead of a String. `Prompt#to_s` gives the previous single-text form.
+- Prompts are sent as two messages: instructions in the system message, the text alone in the user message, between delimiters, with a rule telling the model to treat it as data.
+- `Client#complete` takes `json: false`. The gem's own calls pass `json: true`, which sends `response_format: json_object`.
+- 182 languages instead of 13: every ISO 639-1 code named by CLDR. `SUPPORTED_LANGUAGES` keeps the native names, unchanged for the original 13, and `supported_languages` returns a much longer string. Quality depends on the model and is weaker for rare languages.
+- In `translate_batch` and the batch path of `translate_to_multiple`, an unreadable response fails its own item (`nil`) instead of the whole batch.
+- `translate_auto`, `translate_to_multiple` and the summaries enforce the same 50,000 character limit as `translate`.
+
+### Added
+
+- `config.proxy`: an `http://` proxy URL or URI, or `:env` to read `HTTPS_PROXY`, then `HTTP_PROXY`, honouring `NO_PROXY`. Disabled by default.
+- `preserve_html:` in `translate_batch` and `translate_auto`.
+- `context:` and `style:` in every summary method.
+- English and French language names are accepted in place of codes (`"German"`, `"allemand"`), and locale suggestions are based on language names.
+- `bin/generate_languages` regenerates `lib/mistral_translator/data/languages.json` from CLDR (macOS).
+
+### Fixed
+
+- `Helpers.smart_summarize` raised `ArgumentError` on every call.
+- A translated text mentioning "rate limit" or "quota exceeded" was taken for a rate limit, retried, then failed. Only the 429 status counts now.
+- Context and glossary were formatted three different ways; an empty glossary printed `GLOSSAIRE : {}` in quality check prompts, and the `has_context` / `has_glossary` metadata were never set.
+- `translate_batch` silently ignored misspelled options.
+- Locale suggestions returned unrelated codes once every ISO 639-1 language was supported.
+
+### Security
+
+- User text and API responses no longer reach logs or error messages: the verbose request log records sizes only, error messages carry no response content, errors no longer keep the original Ruby error as `cause`, and the error callback receives the sanitized error. The response stays available through `InvalidResponseError#raw_response`.
+- Delimiters found in the text are neutralised so it cannot close its block, and `Prompt#inspect` shows lengths only.
+- `https://` proxies are rejected: net-http-persistent talks to the proxy in clear, so their credentials would travel unencrypted.
+
+### Removed
+
+- `TranslatorHelpers::PromptHandler` and the test-only `make_request` fallback in `perform_client_request`.
+
+## [0.3.2] - 2026-10-28
+
+### Fixed
+
+- Rich text adapters send the stored ActionText HTML (`to_html`) instead of the rendered one (`to_s`), which wrapped every translation in an extra `<div class="trix-content">` and inlined the rendered attachments. `ActionText::Content` values are now recognised too, not only `ActionText::RichText`.
+- `RecordTranslationService` passes `preserve_html: true` for rich text fields.
+- `RecordTranslationService#translate_to_all_locales` returns `false` when a translation fails. It returned `true`, so failures went unnoticed; successful translations are still saved.
+- `RecordTranslationService`, `Translator` and `Summarizer` stop retrying after a few `RateLimitError`s and raise, instead of retrying forever on top of the client's own backoff.
+- `translate_to_multiple` passes `preserve_html` to each translation; the option was ignored.
+- `translate_with_mistral` raised `ArgumentError` on every call. `from:` is now the source locale and `to:` the target locales, through a new `target_locales:` option of `RecordTranslationService`.
+- A glossary given as a string no longer raises `NoMethodError` in `PromptBuilder`.
+- `BasicRateLimiter` no longer sleeps while holding its lock, which blocked every other thread.
+- HTTP error messages no longer end with a stray brace.
+
+### Changed
+
+- CI token restricted to read access, and development dependencies updated (addressable, json, uri).
+
+### Removed
+
+- Unused helpers `log_prompt_debug` and `build_html_validation_instruction`.
+
 ## [0.3.1] - 2026-10-27
 
 ### Fixed

data/README.md

@@ -30,14 +30,16 @@ MistralTranslator.translate("Bonjour le monde", from: "fr", to: "en")
 - **Native Rails integration** (Mobility, Globalize, I18n attributes)
 - **Batch processing** for high-volume translations
 - **Multi-level summarization** with translation
-- **Robust error handling** with automatic retry and fallback
+- **Robust error handling** with automatic retries; unusable responses raise instead of being returned
 - **Complete monitoring** with metrics and callbacks
 - **Thread-safe & concurrent** with connection pooling ([docs](https://peyochanchan.github.io/mistral_translator/#/advanced-usage/concurrent-async))
 - **Built-in rate limiting** and security
 
 ## Supported Languages
 
-`fr` `en` `es` `pt` `de` `it` `nl` `ru` `mg` `ja` `ko` `zh` `ar`
+All 182 ISO 639-1 languages named by CLDR (`fr`, `en`, `es`, `de`, `ja`, `br`, `wo`, `mg`…). `MistralTranslator.supported_locales` lists them, and English or French names are accepted in place of codes (`"German"`, `"allemand"`).
+
+Translation quality depends on the Mistral model: excellent for widely used languages, weaker for rare ones. Check the output before relying on a rare language.
 
 ## Installation
 
@@ -162,6 +164,8 @@ MistralTranslator.configure do |config|
   config.model = "mistral-small-latest"            # AI model to use (an alias that follows the current Mistral Small)
   config.retry_delays = [1, 2, 4, 8, 16]          # Retry delays in seconds
   config.enable_metrics = true                     # Enable performance metrics
+  config.proxy = :env                              # HTTP proxy: nil (default), "http://host:port", or :env
+                                                   # to read HTTPS_PROXY / HTTP_PROXY and NO_PROXY
 
   # Callbacks for monitoring
   config.on_translation_complete = ->(from, to, orig_len, trans_len, duration) {
@@ -188,6 +192,9 @@ rescue MistralTranslator::AuthenticationError
 rescue MistralTranslator::UnsupportedLanguageError => e
   # Language not supported
   Rails.logger.error "Language '#{e.language}' not supported"
+rescue MistralTranslator::InvalidResponseError, MistralTranslator::EmptyTranslationError
+  # The model kept returning an unusable answer after the retries: nothing is returned
+  Rails.logger.error "Translation unavailable"
 rescue MistralTranslator::Error => e
   # General error handling
   Rails.logger.error "Translation failed: #{e.message}"

data/docs/api-reference/configuration.md

@@ -17,9 +17,26 @@ MistralTranslator.configure do |config|
   config.default_temperature = 0.3               # Créativité (0-1)
   config.retry_delays = [2, 4, 8, 16, 32]       # Délais retry (secondes)
   config.enable_metrics = false                  # Suivi des stats
+  config.proxy = nil                             # Proxy HTTP (désactivé par défaut)
 end
 ```
 
+## Proxy
+
+Désactivé par défaut. Trois valeurs possibles :
+
+```ruby
+config.proxy = nil                                  # Aucun proxy (défaut)
+config.proxy = "http://user:password@proxy:3128"    # Ce proxy (String ou URI)
+config.proxy = :env                                 # HTTPS_PROXY, puis HTTP_PROXY ; NO_PROXY respecté
+```
+
+- Seuls les proxys `http://` sont acceptés. La bibliothèque HTTP utilisée parle toujours en clair au proxy : avec `https://`, les identifiants du proxy circuleraient sans chiffrement. Le flux vers l'API Mistral reste chiffré de bout en bout (tunnel `CONNECT` puis TLS).
+- Avec `:env`, `NO_PROXY` suit les règles de curl : `*`, un domaine et ses sous-domaines (`mistral.ai`, `.mistral.ai`, `*.mistral.ai`), éventuellement avec le port 443.
+- Une valeur invalide lève `ConfigurationError` dès l'affectation ; le message ne reprend jamais l'URL, pour ne pas exposer les identifiants.
+- `api_url` reste verrouillée sur `https://api.mistral.ai`.
+- Définissez le proxy avant la première traduction : le client et sa connexion sont créés une fois puis réutilisés.
+
 ## Callbacks
 
 ```ruby
@@ -63,9 +80,9 @@ config.setup_rails_logging  # Active les logs Rails standard
 MistralTranslator.health_check
 # => { status: :ok, message: "API connection successful" }
 
-# Langues supportées
+# Langues supportées : les 182 codes ISO 639-1
 MistralTranslator.supported_locales
-# => ["fr", "en", "es", "pt", "de", "it", "nl", "ru", "mg", "ja", "ko", "zh", "ar"]
+# => ["aa", "ab", "ae", "af", ..., "zh", "zu"]
 ```
 
 ---

data/docs/api-reference/errors.md

@@ -210,8 +210,10 @@ end
 
 **Attributs:**
 
-- `message` (String) - Description de l'erreur
-- `raw_response` (String, optionnel) - Réponse brute reçue
+- `message` (String) - Description de l'erreur. Elle ne contient jamais la réponse de l'API, pour qu'aucun texte traduit ne finisse dans les journaux.
+- `raw_response` (String, optionnel) - Réponse brute reçue, accessible au code appelant uniquement
+
+L'erreur Ruby d'origine (`JSON::ParserError`, `NoMethodError`…) n'est pas conservée dans `cause` : son message cite la réponse.
 
 **Causes courantes:**
 
@@ -321,13 +323,13 @@ end
 
 ### `MistralTranslator::SecurityError`
 
-**Description:** Violation de sécurité détectée.
+**Statut:** définie pour usage futur ; la gem ne la lève actuellement nulle part. Inutile de la rattraper.
 
-**Causes courantes:**
+Les contrôles de sécurité existants lèvent d'autres erreurs :
 
-- Texte dépassant la taille limite (50,000 caractères)
-- Contenu potentiellement malveillant détecté
-- Tentative d'injection de prompt
+- Texte de plus de 50 000 caractères : `ArgumentError` (traductions, détection automatique et résumés)
+- Proxy invalide : `ConfigurationError`
+- Instructions glissées dans le texte à traduire : rien n'est levé. Le texte est envoyé à part des consignes (message `user`), entre délimiteurs, avec une règle demandant au modèle de le traiter comme une donnée.
 
 **Exemple:**
 
@@ -344,44 +346,33 @@ end
 **Solutions:**
 
 - Diviser les textes longs en plusieurs parties
-- Valider le contenu avant traduction
 - Utiliser `translate_batch` pour les lots importants
 
 ---
 
 ### `MistralTranslator::RateLimitExceededError`
 
-**Description:** Limite de taux personnalisée dépassée.
+**Statut:** définie pour usage futur ; la gem ne la lève actuellement nulle part.
 
 **Attributs:**
 
 - `wait_time` (Integer, optionnel) - Temps d'attente suggéré
 - `retry_after` (Integer, optionnel) - Timestamp de retry
 
-**Différence avec `RateLimitError`:**
+**Comportement réel des limites de débit:**
 
-- `RateLimitError` : Limite API Mistral (HTTP 429)
-- `RateLimitExceededError` : Limite locale de la gem
-
-**Exemple:**
+- Limite locale (`Security::BasicRateLimiter`) : la requête **attend** qu'un créneau se libère, sans lever d'erreur.
+- Limite de l'API Mistral (HTTP 429) : le client relance avec les délais de `config.retry_delays`, puis lève `RateLimitError`.
 
 ```ruby
-# Configuration du rate limiter local
 rate_limiter = MistralTranslator::Security::BasicRateLimiter.new(
   max_requests: 10,
   window_seconds: 60
 )
-
 client = MistralTranslator::Client.new(rate_limiter: rate_limiter)
 
-begin
-  # Trop de requêtes locales
-  15.times { client.complete("Hello") }
-rescue MistralTranslator::RateLimitExceededError => e
-  puts "Local rate limit exceeded"
-  sleep(e.wait_time) if e.wait_time
-  retry
-end
+# Au-delà de 10 requêtes par minute, les appels attendent leur tour
+15.times { client.complete("Hello") }
 ```
 
 ---

data/docs/api-reference/methods.md

@@ -62,8 +62,13 @@ Traduit un texte avec détection automatique de la langue source.
 - `to` (String|Symbol) - Code de langue cible
 - `context` (String, optionnel) - Contexte pour la traduction
 - `glossary` (Hash, optionnel) - Dictionnaire de termes
+- `preserve_html` (Boolean, optionnel) - Préserve les balises HTML (défaut: false)
 
-**Retour:** String - Le texte traduit
+**Retour:** String - Le texte traduit (le texte d'origine si la langue détectée est déjà la langue cible)
+
+**Exceptions:**
+
+- `InvalidResponseError` - Détection illisible ou langue non supportée : aucune langue n'est supposée
 
 **Exemple:**
 
@@ -118,8 +123,9 @@ Traduit plusieurs textes en une fois pour optimiser les performances.
 - `to` (String|Symbol) - Code de langue cible
 - `context` (String, optionnel) - Contexte commun pour tous les textes
 - `glossary` (Hash, optionnel) - Dictionnaire de termes
+- `preserve_html` (Boolean, optionnel) - Préserve les balises HTML (défaut: false)
 
-**Retour:** Hash - Hash avec les index comme clés et traductions comme valeurs
+**Retour:** Hash - Hash avec les index comme clés et traductions comme valeurs. Un élément dont la requête ou la réponse échoue vaut `nil`, sans faire échouer le lot.
 
 **Exemple:**
 
@@ -292,7 +298,7 @@ Remet la configuration aux valeurs par défaut.
 
 Retourne la liste des codes de langue supportés.
 
-**Retour:** Array<String> - Liste des codes (ex: ["fr", "en", "es"])
+**Retour:** Array<String> - Liste des 182 codes ISO 639-1 (ex: ["aa", "ab", ..., "zu"])
 
 ### `supported_languages`
 
@@ -399,7 +405,7 @@ Client HTTP pour l'API Mistral.
 
 **Méthodes d'instance:**
 
-- `complete(prompt, max_tokens: nil, temperature: nil, context: {})` - Complétion
+- `complete(prompt, max_tokens: nil, temperature: nil, context: {}, json: false)` - Complétion ; `json: true` demande un objet JSON à l'API (`response_format: json_object`), le prompt devant décrire le JSON attendu
 - `chat(prompt, max_tokens: nil, temperature: nil, context: {})` - Chat
 - `translate_batch(requests, batch_size: 5)` - Traduction par lots
 

data/docs/getting-started.md

@@ -39,15 +39,21 @@ MistralTranslator.translate_auto("Guten Tag", to: "fr")
 ## 🌍 Langues Supportées
 
 ```ruby
-# Vérifier les langues disponibles
+# Les 182 langues ISO 639-1 sont disponibles
 MistralTranslator::LocaleHelper.supported_locales
-# => ["fr", "en", "es", "pt", "de", "it", "nl", "ru", "mg", "ja", "ko", "zh", "ar"]
+# => ["aa", "ab", "ae", "af", ..., "zh", "zu"]
+
+# Les noms anglais et français sont acceptés à la place du code
+MistralTranslator::LocaleHelper.language_to_locale("allemand")
+# => "de"
 
 # Vérifier une langue spécifique
 MistralTranslator::LocaleHelper.locale_supported?("ja")
 # => true
 ```
 
+La qualité de traduction dépend du modèle Mistral : excellente pour les langues les plus parlées, plus faible pour les langues rares. Vérifiez le résultat avant de vous appuyer sur une langue rare.
+
 ## 🚨 Gestion d'Erreurs Simple
 
 ```ruby

data/lib/mistral_translator/adapters.rb

@@ -43,24 +43,35 @@ module MistralTranslator
         value = get_field_value(field, locale)
         return false if value.nil?
 
-        # Gestion des rich text
-        if defined?(ActionText::RichText) && value.is_a?(ActionText::RichText)
-          !value.to_plain_text.to_s.strip.empty?
-        else
-          !value.to_s.strip.empty?
-        end
+        text = rich_text?(value) ? value.to_plain_text : value
+        !text.to_s.strip.empty?
       end
 
       def get_translatable_content(field, locale)
         value = get_field_value(field, locale)
         return nil if value.nil?
 
-        # Gestion des rich text - préserver le HTML
-        if defined?(ActionText::RichText) && value.is_a?(ActionText::RichText)
-          value.body.to_s
-        else
-          value.to_s
-        end
+        rich_text?(value) ? rich_text_html(value) : value.to_s
+      end
+
+      # ActionText::RichText (has_rich_text) ou ActionText::Content (son body)
+      def rich_text?(value)
+        (defined?(ActionText::RichText) && value.is_a?(ActionText::RichText)) ||
+          (defined?(ActionText::Content) && value.is_a?(ActionText::Content))
+      end
+
+      def rich_text_field?(field, locale)
+        rich_text?(get_field_value(field, locale))
+      end
+
+      private
+
+      # HTML tel que stocké, pièces jointes réduites à <action-text-attachment>.
+      # to_s rendrait le layout (<div class="trix-content">) et le contenu des
+      # pièces jointes, qui seraient alors enregistrés dans la traduction.
+      def rich_text_html(value)
+        content = value.respond_to?(:body) ? value.body : value
+        content&.to_html.to_s
       end
     end
 
@@ -167,16 +178,22 @@ module MistralTranslator
   # Service de traduction utilisant les adaptateurs
   module Adapters
     class RecordTranslationService
-      def initialize(record, translatable_fields, adapter: nil, source_locale: nil)
+      MAX_RATE_LIMIT_RETRIES = 3
+
+      # target_locales : toutes les locales de l'adaptateur par défaut
+      def initialize(record, translatable_fields, adapter: nil, source_locale: nil, target_locales: nil)
         @record = record
         @translatable_fields = Array(translatable_fields)
         @adapter = adapter || Adapters::AdapterFactory.build_for(record)
         @source_locale = source_locale
+        @target_locales = target_locales&.map(&:to_sym)
       end
 
+      # Enregistre les traductions obtenues ; renvoie false si l'une a échoué.
       def translate_to_all_locales
         return false if @translatable_fields.empty?
 
+        @failed = false
         ActiveRecord::Base.transaction do
           @translatable_fields.each do |field|
             translate_field(field)
@@ -184,7 +201,7 @@ module MistralTranslator
           @adapter.save_record!
         end
 
-        true
+        !@failed
       rescue StandardError => e
         Rails.logger.error "Translation failed: #{e.message}" if defined?(Rails)
         false
@@ -198,34 +215,57 @@ module MistralTranslator
 
         return if source_content.nil? || source_content.strip.empty?
 
+        options = rich_text_field?(field, source_locale) ? { preserve_html: true } : {}
         target_locales = @adapter.available_locales - [source_locale]
+        target_locales &= @target_locales if @target_locales
 
         target_locales.each do |target_locale|
-          translate_to_locale(field, source_content, source_locale, target_locale)
-          sleep(2) # Rate limiting basique
+          translated = translate_to_locale(field, source_content, source_locale, target_locale, options)
+          sleep(2) if translated # Rate limiting basique
         end
       end
 
-      def translate_to_locale(field, content, source_locale, target_locale)
-        translated_content = MistralTranslator.translate(
-          content,
-          from: source_locale.to_s,
-          to: target_locale.to_s
-        )
+      # Les adaptateurs fournis par l'application n'héritent pas forcément de BaseAdapter.
+      def rich_text_field?(field, locale)
+        @adapter.respond_to?(:rich_text_field?) && @adapter.rich_text_field?(field, locale)
+      end
 
-        if translated_content && !translated_content.strip.empty?
-          @adapter.set_field_value(field, target_locale,
-                                   translated_content)
-        end
-      rescue MistralTranslator::RateLimitError => e
-        Rails.logger.warn "Rate limit: #{e.message}" if defined?(Rails)
-        sleep(2)
-        retry
-      rescue StandardError => e
-        if defined?(Rails)
-          Rails.logger.error "Translation error for #{field} #{source_locale}->#{target_locale}: #{e.message}"
+      def translate_to_locale(field, content, source_locale, target_locale, options)
+        rate_limit_retries = 0
+        begin
+          translated_content = MistralTranslator.translate(
+            content,
+            from: source_locale.to_s,
+            to: target_locale.to_s,
+            **options
+          )
+
+          if translated_content && !translated_content.strip.empty?
+            @adapter.set_field_value(field, target_locale,
+                                     translated_content)
+          end
+          true
+        rescue MistralTranslator::RateLimitError => e
+          Rails.logger.warn "Rate limit: #{e.message}" if defined?(Rails)
+          rate_limit_retries += 1
+          if rate_limit_retries <= MAX_RATE_LIMIT_RETRIES
+            sleep(2)
+            retry
+          end
+          record_failure(field, source_locale, target_locale, e)
+          false
+        rescue StandardError => e
+          record_failure(field, source_locale, target_locale, e)
+          false
         end
       end
+
+      def record_failure(field, source_locale, target_locale, error)
+        @failed = true
+        return unless defined?(Rails)
+
+        Rails.logger.error "Translation error for #{field} #{source_locale}->#{target_locale}: #{error.message}"
+      end
     end
   end
 

data/lib/mistral_translator/client.rb

@@ -22,7 +22,9 @@ module MistralTranslator
       @rate_limiter = rate_limiter || Security::BasicRateLimiter.new
     end
 
-    def complete(prompt, max_tokens: nil, temperature: nil, context: {})
+    # json: true demande un objet JSON à l'API (response_format json_object) ;
+    # le prompt doit alors décrire le JSON attendu.
+    def complete(prompt, max_tokens: nil, temperature: nil, context: {}, json: false)
       # Vérifier le rate limit avant de faire la requête
       @rate_limiter.wait_and_record!
 
@@ -30,14 +32,15 @@ module MistralTranslator
       start_time = Time.now
       trigger_translation_start_callback(ctx, prompt)
 
-      response = make_request_with_retry(prompt, max_tokens, temperature, ctx)
+      request_options = { max_tokens: max_tokens, temperature: temperature, json: json }
+      response = make_request_with_retry(prompt, request_options, ctx)
       content = extract_content_from_response(response)
 
       trigger_translation_complete_callback(ctx, prompt, content, start_time)
       content
     rescue JSON::ParserError => e
       handle_json_parse_error(e, ctx)
-    rescue NoMethodError => e
+    rescue NoMethodError, TypeError => e
       handle_response_structure_error(e, ctx)
     end
 
@@ -49,14 +52,14 @@ module MistralTranslator
       start_time = Time.now
       trigger_translation_start_callback(ctx, prompt)
 
-      response = make_request_with_retry(prompt, max_tokens, temperature, ctx)
+      response = make_request_with_retry(prompt, { max_tokens: max_tokens, temperature: temperature }, ctx)
       content = extract_chat_content_from_response(response)
 
       trigger_translation_complete_callback(ctx, prompt, content, start_time)
       content
     rescue JSON::ParserError => e
       handle_json_parse_error(e, ctx)
-    rescue NoMethodError => e
+    rescue NoMethodError, TypeError => e
       handle_response_structure_error(e, ctx)
     end
 
@@ -122,29 +125,25 @@ module MistralTranslator
       )
     end
 
-    def handle_json_parse_error(error, context)
-      MistralTranslator.configuration.trigger_translation_error(
-        context[:from_locale],
-        context[:to_locale],
-        error,
-        context[:attempt] || 0
-      )
-      message = if context[:operation] == :chat
-                  "JSON parse error: #{error.message}"
-                else
-                  "Invalid JSON in API response: #{error.message}"
-                end
-      raise InvalidResponseError, message
+    # Le message de JSON::ParserError, NoMethodError ou TypeError cite la réponse de l'API :
+    # ni lui ni l'erreur d'origine (cause) ne sont repris, et le callback reçoit l'erreur nettoyée.
+    def handle_json_parse_error(_error, context)
+      raise_invalid_response("Invalid JSON in API response", context)
     end
 
     def handle_response_structure_error(error, context)
+      raise_invalid_response("Invalid response structure (#{error.class})", context)
+    end
+
+    def raise_invalid_response(message, context)
+      error = InvalidResponseError.new(message)
       MistralTranslator.configuration.trigger_translation_error(
         context[:from_locale],
         context[:to_locale],
         error,
         context[:attempt] || 0
       )
-      raise InvalidResponseError, "Invalid response structure: #{error.message}"
+      raise error, cause: nil
     end
   end
 end