fix: allow endpoint callers to select transcription language

README.md

@@ -80,6 +80,37 @@ print(f"Transcription: {transcription}")
 
 -----
 
+### Hosted inference endpoint: selecting a language
+
+For an endpoint deployed with `handler.py`, send a JSON request with the
+language in `parameters.language`:
+
+```json
+{
+  "inputs": "<base64-encoded audio file>",
+  "parameters": {"language": "en"}
+}
+```
+
+Whisper accepts language codes, names, or language tokens, for example `"en"`,
+`"english"`, or `"<|en|>"` for English and `"zh"` for Mandarin Chinese.
+The endpoint passes the selected language to Whisper with `task="transcribe"`
+so the output stays in the source language rather than translating it.
+The same `parameters` object works with `{"inputs": {"audio": "..."}}`
+and `{"audio": "..."}` requests. Use JSON to select a language; raw binary
+requests do not carry parameters.
+
+Omitting `language` or setting it to `null` preserves the model's default
+generation behavior. The checked-in generation configuration leaves the
+language unspecified, allowing Whisper to detect it automatically; the handler
+does not force Mandarin. A language override applies only to its own request.
+Unsupported language strings are rejected by Whisper using the handler's
+existing error response format.
+
+Language selection enables cross-language benchmarking, but this model was
+fine-tuned on Mandarin and improvements in other languages have not been
+established. Redeploy the endpoint after merging handler changes to use this option.
+
 ## Training Data
 
 The model was fine-tuned on the **[AImpower/MandarinStutteredSpeech](https://huggingface.co/datasets/AImpower/MandarinStutteredSpeech)** dataset.  
@@ -134,4 +165,4 @@ If you use this model, please cite the original paper:
   location = {Athens, Greece},
   series = {FAccT '25}
 }
-```
+```

handler.py

@@ -9,6 +9,7 @@ import numpy as np
 import base64
 import io
 import logging
+from copy import deepcopy
 from typing import Dict, Any
 from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
 
@@ -101,6 +102,9 @@ class EndpointHandler:
         1. {"inputs": "base64_encoded_audio_string"}
         2. {"inputs": {"audio": "base64_encoded_audio_string"}}
         3. Binary audio data in request body
+
+        Dictionary requests may include {"parameters": {"language": "en"}}.
+        Omit language (or use null) to keep the model's default behavior.
         
         Args:
             data: Input data dictionary
@@ -110,6 +114,23 @@ class EndpointHandler:
         """
         try:
             logger.info("Processing inference request...")
+
+            generate_kwargs = {}
+            if isinstance(data, dict):
+                parameters = data.get("parameters", {})
+                if not isinstance(parameters, dict):
+                    raise ValueError("'parameters' must be a dictionary")
+                language = parameters.get("language")
+                if language is not None:
+                    if not isinstance(language, str) or not language.strip():
+                        raise ValueError("'language' must be a non-empty string or null")
+                    # Keep language overrides local to this request, including on
+                    # Transformers versions that modify the generation config.
+                    generate_kwargs = {
+                        "generation_config": deepcopy(self.model.generation_config),
+                        "language": language.strip(),
+                        "task": "transcribe",
+                    }
             
             # Extract audio data from various input formats
             waveform = None
@@ -170,9 +191,9 @@ class EndpointHandler:
             # Move to device
             input_features = input_features.to(self.device, dtype=self.torch_dtype)
             
-            # Run inference with forced Mandarin Chinese language
+            # Use the requested language, or the model's defaults when omitted.
             with torch.no_grad():
-                predicted_ids = self.model.generate(input_features)
+                predicted_ids = self.model.generate(input_features, **generate_kwargs)
             
             # Decode transcription
             transcription = self.processor.batch_decode(

tests/test_handler.py

@@ -0,0 +1,83 @@
+"""Handler regression tests; no model weights or endpoint required."""
+
+import unittest
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+from handler import EndpointHandler
+
+
+class LanguageTests(unittest.TestCase):
+    def setUp(self):
+        self.handler = EndpointHandler.__new__(EndpointHandler)
+        self.handler.device = "cpu"
+        self.handler.torch_dtype = None
+        self.handler.model = Mock()
+        self.handler.model.generation_config = SimpleNamespace(language=None)
+        self.features = Mock()
+        self.features.to.return_value = self.features
+        self.handler.processor = Mock(return_value=SimpleNamespace(input_features=self.features))
+        self.handler.processor.batch_decode.return_value = [" test transcription "]
+        self.handler._load_audio_from_base64 = Mock(return_value=[0.0] * 16000)
+        self.handler._load_audio_from_bytes = Mock(return_value=[0.0] * 16000)
+
+    def assert_success(self, request):
+        self.assertEqual(self.handler(request), {
+            "transcription": "test transcription",
+            "audio_duration_seconds": 1.0,
+            "model": "AImpower/StutteredSpeechASR",
+        })
+
+    def test_languages_and_json_audio_formats(self):
+        for language in ("en", "english", "<|en|>", "zh", " en "):
+            for audio in ({"inputs": "audio"}, {"inputs": {"audio": "audio"}},
+                          {"audio": "audio"}, {"inputs": b"audio"}):
+                with self.subTest(language=language, audio=audio):
+                    self.assert_success({**audio, "parameters": {"language": language}})
+                    args, kwargs = self.handler.model.generate.call_args
+                    self.assertEqual(args, (self.features,))
+                    self.assertEqual(kwargs["language"], language.strip())
+                    self.assertEqual(kwargs["task"], "transcribe")
+                    self.assertIsNot(kwargs["generation_config"], self.handler.model.generation_config)
+
+    def test_default_requests_keep_existing_generation_call(self):
+        for request in ({"inputs": "audio"}, {"inputs": "audio", "parameters": {}},
+                        {"inputs": "audio", "parameters": {"language": None}},
+                        b"audio", bytearray(b"audio")):
+            with self.subTest(request=request):
+                self.assert_success(request)
+                self.handler.model.generate.assert_called_with(self.features)
+
+    def test_language_does_not_leak_between_requests(self):
+        def generate(features, **kwargs):
+            if "generation_config" in kwargs:
+                kwargs["generation_config"].language = kwargs["language"]
+            return [[1]]
+        self.handler.model.generate.side_effect = generate
+        for language in ("en", "zh"):
+            self.assert_success({"inputs": "audio", "parameters": {"language": language}})
+            self.assertIsNone(self.handler.model.generation_config.language)
+        self.assert_success({"inputs": "audio"})
+        self.handler.model.generate.assert_called_with(self.features)
+
+    def test_invalid_parameter_shapes_return_existing_error_format(self):
+        for parameters in (None, [], "en", {"language": ""}, {"language": " "},
+                           {"language": 123}, {"language": ["en"]}):
+            with self.subTest(parameters=parameters):
+                result = self.handler({"inputs": "audio", "parameters": parameters})
+                self.assertIsNone(result["transcription"])
+                self.assertIn("error", result)
+        self.handler.model.generate.assert_not_called()
+
+    def test_unsupported_language_error_is_returned(self):
+        self.handler.model.generate.side_effect = ValueError("Unsupported language: invalid")
+        result = self.handler({"inputs": "audio", "parameters": {"language": "invalid"}})
+        self.assertEqual(result, {"error": "Unsupported language: invalid", "transcription": None})
+
+    def test_unrelated_parameters_are_not_forwarded(self):
+        self.assert_success({"inputs": "audio", "parameters": {"max_new_tokens": 1}})
+        self.handler.model.generate.assert_called_with(self.features)
+
+
+if __name__ == "__main__":
+    unittest.main()