mistral_translator 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 242809c8a55ea79c9c436a2fc7b17d7a6deda5372090eaaa43b9a0863e1ba552
-  data.tar.gz: b6f86bc08b253f5ea4097e9fa1f3e901e41886067155c2fc595202694ce18acb
+  metadata.gz: 22b02e4c378ffdd992bbb525c57a03fd15c4c82e2ee916c43a3753b09398c8e0
+  data.tar.gz: 1bdf19928ac211fbbc7e7fe064f600d53639c3b0aa57063b14b74fe3b95384c0
 SHA512:
-  metadata.gz: 6183a2226ee0985e5229c2cb203fed6cfb71ced4c2a0cdb28fba16115f5b6fdf28b860baba50db8f3461e64792267558f3413481e715c54f2f1b5bf0747d3647
-  data.tar.gz: a71be86ea71b15e50af048cbba672e5fdecd41e6d3cd1e1313d534d11d2af7747ac593cf36791ad805f9b6db4ff6d6d88853a8b166a046cc45747a66e879bf0c
+  metadata.gz: 67bb96d4142aa345f2feb2f1cf35ef30e131d529ad22338e9bd31c0c237d165a446b74e8ed75aa7715d903e486657250fb823e4add5994edade18d763fa50e2f
+  data.tar.gz: 39fcfd92f88aa10bb1ca930a8c9539a9d3e12ce7a8b4d1564d2cd0336ac5f349d9903334abec4a7f0d8fe8876a90d82738d8e6bc2a024bc91df5303c8f096588

data/CHANGELOG.md

@@ -1,4 +1,78 @@
-## [Unreleased]
+## [0.5.0] - 2026-10-29
+
+### Added
+
+- `config.read_timeout`: how long to wait for the API's answer, in seconds. Defaults to 60, the value the gem used until now; anything but a positive number raises `ConfigurationError` when it is set.
+- `config.open_timeout`: how long to wait for the connection to open (TCP, then TLS), in seconds. Defaults to 60, validated the same way.
+
+### Changed
+
+No change to translation results:
+
+- Translations and summaries share one retry policy, with the same delays and counts as before. Their retry log lines now share one format, such as `translation retry 1/3 for fr->en in 2s: …`.
+- The `Summarizer` no longer prints to stdout when `MISTRAL_TRANSLATOR_TEST_OUTPUT` is set.
+- A response is parsed once instead of twice.
+
+### Deprecated
+
+These options still work, print a warning, and will be removed in 1.0:
+
+- `config.ssl_timeout`, the former name of `open_timeout`, which it still sets. It is now validated like `open_timeout`, so `nil` (no limit) is rejected.
+- `config.default_max_tokens` and `config.default_temperature`, which the gem never read.
+
+### Removed
+
+Undocumented code that the gem never called:
+
+- the `HelpersExtensions` copies of `translate_with_progress`, `translate_multi_style` and `find_locale_suggestions`, which `Helpers` redefines;
+- `TranslatorHelpers::RetryHandler`, `TranslatorHelpers::LoggingHelper` and `InputValidator#validate_batch_inputs!`;
+- `PromptBuilder.bulk_translation_prompt`, `PromptBuilder.tiered_summary_prompt`, `PromptHelpers::FormatInstructions`, `ResponseParser.parse_bulk_translation_response` and `ResponseParser::JsonParserState`.
+
+### Security
+
+- When the scan for a JSON object inside text reached its limit, the error kept the `JSON::ParserError` as its `cause`, and that error quotes the response.
+
+## [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
 

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"`). The list and the names come from the CLDR data of macOS 27.2, through `bin/generate_languages` (2026-10-28).
+
+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,11 @@ 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
+  config.open_timeout = 60                         # Seconds to open the connection (default 60)
+  config.read_timeout = 60                         # Seconds to wait for the API's answer (default 60);
+                                                   # raise it for long texts or summaries
 
   # Callbacks for monitoring
   config.on_translation_complete = ->(from, to, orig_len, trans_len, duration) {
@@ -174,6 +181,8 @@ MistralTranslator.configure do |config|
 end
 ```
 
+Configure the gem before the first call. The module-level methods (`MistralTranslator.translate`, `summarize`…) share one client, which reads `api_key`, `model`, `api_url`, `retry_delays` and the connection settings (`read_timeout`, `proxy`, SSL) on the first call. To change them afterwards, call `MistralTranslator.reset_configuration!` and configure again, or create a `MistralTranslator::Translator.new` (or `Summarizer.new`), which builds its own client from the current configuration.
+
 ## Error Handling
 
 ```ruby
@@ -188,6 +197,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

@@ -13,13 +13,53 @@ MistralTranslator.configure do |config|
   config.api_key = ENV['MISTRAL_API_KEY']        # Obligatoire
   config.model = "mistral-small-latest"                 # Défaut
   config.api_url = "https://api.mistral.ai"      # URL API
-  config.default_max_tokens = 4000               # Limite tokens
-  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)
+  config.open_timeout = 60                       # Ouverture de la connexion (secondes)
+  config.read_timeout = 60                       # Attente maximale de la réponse (secondes)
 end
 ```
 
+Configurez la gem avant le premier appel. Les méthodes du module (`MistralTranslator.translate`, `summarize`…) partagent un client, qui lit `api_key`, `model`, `api_url`, `retry_delays` et les réglages de connexion (`read_timeout`, `proxy`, SSL) lors du premier appel. Pour les changer ensuite, appelez `MistralTranslator.reset_configuration!` puis configurez à nouveau, ou créez un `MistralTranslator::Translator.new` (ou `Summarizer.new`), qui construit son propre client avec la configuration du moment.
+
+## Délais
+
+Deux délais, en secondes, 60 par défaut :
+
+- `open_timeout` : ouverture de la connexion à l'API (TCP puis TLS) ;
+- `read_timeout` : attente de la réponse. Un long texte ou un résumé détaillé peut demander plus au modèle ; augmentez-le dans ce cas.
+
+```ruby
+config.read_timeout = 180
+```
+
+- Seul un nombre strictement positif est accepté (entier ou décimal) ; toute autre valeur lève `ConfigurationError` dès l'affectation.
+- Délai de réponse dépassé : la requête lève `ApiError` (« Request timeout »).
+
+## Options obsolètes
+
+Elles fonctionnent encore, avec un avertissement, et seront retirées en 1.0 :
+
+- `ssl_timeout` : ancien nom d'`open_timeout`, qu'il règle toujours ;
+- `default_max_tokens` et `default_temperature` : jamais lues par la gem, elles n'ont aucun effet. Pour régler ces paramètres, passez `max_tokens:` et `temperature:` à `Client#chat` ou `Client#complete`.
+
+## 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 +103,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,23 @@ 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 liste et les noms viennent des données CLDR de macOS 27.2, via `bin/generate_languages` (2026-10-28).
+
+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/docs/installation.md

@@ -79,8 +79,6 @@ MistralTranslator.configure do |config|
   config.model = "mistral-small-latest"                # Modèle par défaut
   config.retry_delays = [2, 4, 8, 16]          # Délais retry
   config.enable_metrics = true                  # Suivi des stats
-  config.default_max_tokens = 4000              # Limite tokens
-  config.default_temperature = 0.3              # Créativité
 end
 ```
 

data/docs/rails-integration/setup.md

@@ -272,7 +272,6 @@ MistralTranslator.configure do |config|
 
   # Optimisation Rails
   config.enable_metrics = true
-  config.default_max_tokens = 4000
 
   # Cache intelligent des traductions
   config.on_translation_complete = ->(from, to, orig_len, trans_len, duration) {

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

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,18 +22,22 @@ 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
         @http_pool ||= begin
           pool = Net::HTTP::Persistent.new(name: "mistral_translator")
-          pool.read_timeout = 60
+          pool.read_timeout = MistralTranslator.configuration.read_timeout
           pool.idle_timeout = 30
-          pool.open_timeout = MistralTranslator.configuration.ssl_timeout
+          pool.open_timeout = MistralTranslator.configuration.open_timeout
           pool.max_requests = 100
 
           # 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
@@ -107,18 +127,13 @@ module MistralTranslator
         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)