diff --git a/python/stt/whisperService/README.md b/python/stt/whisperService/README.md
index c3bc6883c6..1e33f9068a 100644
--- a/python/stt/whisperService/README.md
+++ b/python/stt/whisperService/README.md
@@ -7,16 +7,16 @@ You can launch the service by running e.g. `python faster-whisper.py`.
 
 ### Prerequisites
 
-- [Python 3](https://wiki.python.org/moin/BeginnersGuide/Download)
+- [Python 3.9 or newer](https://wiki.python.org/moin/BeginnersGuide/Download)
 - [Pip](https://pip.pypa.io/en/stable/installation/)
 - **Windows**
   - [FFMpeg](https://www.gyan.dev/ffmpeg/builds/) - you can run `winget install ffmpeg` to install the package
 - **Linux**
   - `apt-get -y install python3-pyaudio portaudio19-dev` - needed to install `pyaudio`
-  - `apt-get -y install ffmpeg libavcodec-extra` - needed for pydub
+  - `apt-get -y install ffmpeg libavcodec-extra` - needed for audio decoding
   - `apt-get -y install cudnn9-cuda-12`- Follow instruction in [NVIDIA cuDNN on Linux](https://docs.nvidia.com/deeplearning/cudnn/latest/installation/linux.html) to enable NVIDIA network repository.
 - **MacOS**
-  - `brew install portaudio` - needed to install `pyaudio`
+  - `brew install ffmpeg portaudio` - needed for audio decoding and `pyaudio`
 
 ### Install
 
@@ -46,3 +46,20 @@ You can connect to the whisper service using the example "whisperClient" project
 - Start the web UI using `pnpm run start`
 
 This web client will capture audio from microphone, send to the local service for transcription and show the result.
+
+## Input and processing limits
+
+The service accepts audio files up to **30 MiB** and recordings up to **five minutes**. The complete multipart request has a separate 30 MiB + 64 KiB limit for form headers. Both declared and streamed request sizes are checked before multipart parsing. Once a request reaches the front of the queue, its complete body must arrive within **30 seconds**, including continuously streamed uploads. An upload timeout returns HTTP 408 with an `error` message and releases capacity for the next request; queueing and transcription do not count toward this deadline.
+
+FFmpeg decodes only the first audio stream into 16 kHz mono 16-bit PCM, with bounded output and a 30-second decoding timeout. Oversized files or recordings return HTTP 413, invalid audio returns HTTP 400, and a decoding timeout returns HTTP 422. These responses contain an `error` message instead of transcription text.
+
+One request is processed at a time, and one additional request can wait. Further requests receive HTTP 503 with `Retry-After: 1`. Processing remains reserved until the worker finishes, including when its client cancels. The Shell and example client display failures and stop the failed recording; start a new recording to retry. Delayed results or errors from an earlier recording do not affect a new recording.
+
+## Offline tests
+
+The tests use the installed FFmpeg executable and a small model stand-in, without downloading a Whisper model or requiring a GPU:
+
+```shell
+pip install -r requirements-test.txt
+python -m unittest -v test_audio_limits
+```
diff --git a/python/stt/whisperService/faster-whisper.py b/python/stt/whisperService/faster-whisper.py
index 63cab985f5..90f35929ad 100644
--- a/python/stt/whisperService/faster-whisper.py
+++ b/python/stt/whisperService/faster-whisper.py
@@ -1,25 +1,122 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
-from io import BytesIO
-from pydub import AudioSegment
+import asyncio
+from pathlib import Path
+import subprocess
+import tempfile
 import uvicorn
 import numpy as np
 import torch
-from fastapi import FastAPI, UploadFile, File
+from fastapi import FastAPI, UploadFile, File, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+from starlette.datastructures import Headers, State
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 import logging
 from faster_whisper import WhisperModel
 
 import os
-os.environ['KMP_DUPLICATE_LIB_OK']='True'
+os.environ["KMP_DUPLICATE_LIB_OK"] = "True"
 
 # Configure logging
-logging.basicConfig(level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.ERROR,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+MAX_UPLOAD_BYTES = 30 * 1024 * 1024
+MAX_REQUEST_BYTES = MAX_UPLOAD_BYTES + 64 * 1024
+MAX_AUDIO_SECONDS = 300
+SAMPLE_RATE = 16000
+UPLOAD_TIMEOUT_SECONDS = 30
+DECODE_TIMEOUT_SECONDS = 30
+READ_CHUNK_BYTES = 64 * 1024
+
+
+class TranscriptionInputMiddleware:
+    def __init__(self, app: ASGIApp, state: State) -> None:
+        self.app = app
+        self.state = state
+        self.lock = asyncio.Lock()
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if (
+            scope["type"] != "http"
+            or scope["method"] != "POST"
+            or scope["path"].rstrip("/") != "/transcribe"
+        ):
+            await self.app(scope, receive, send)
+            return
+
+        async def reject(status: int, message: str) -> None:
+            response = JSONResponse(
+                {"error": message},
+                status_code=status,
+                headers={"Retry-After": "1"} if status == 503 else None,
+            )
+            await response(scope, receive, send)
+
+        content_length = Headers(scope=scope).get("content-length")
+        if content_length is not None:
+            if not content_length.isdecimal() or len(content_length) > 20:
+                await reject(400, "Invalid request size.")
+                return
+            if int(content_length) > MAX_REQUEST_BYTES:
+                await reject(
+                    413, "The audio upload exceeds the request size limit."
+                )
+                return
+        if self.state.pending_transcriptions >= 2:
+            await reject(503, "The transcription service is busy. Try again shortly.")
+            return
+
+        self.state.pending_transcriptions += 1
+        try:
+            async with self.lock:
+                with tempfile.SpooledTemporaryFile(max_size=1024 * 1024) as body:
+                    size = 0
+                    loop = asyncio.get_running_loop()
+                    upload_deadline = loop.time() + UPLOAD_TIMEOUT_SECONDS
+                    while True:
+                        try:
+                            message = await asyncio.wait_for(
+                                receive(), timeout=upload_deadline - loop.time()
+                            )
+                        except asyncio.TimeoutError:
+                            await reject(408, "The audio upload exceeded the time limit.")
+                            return
+                        if message["type"] == "http.disconnect":
+                            return
+                        if message["type"] != "http.request":
+                            raise RuntimeError("Unexpected transcription request message.")
+                        chunk = message.get("body", b"")
+                        size += len(chunk)
+                        if size > MAX_REQUEST_BYTES:
+                            await reject(413, "The audio upload exceeds the request size limit.")
+                            return
+                        body.write(chunk)
+                        if not message.get("more_body", False):
+                            break
+                    body.seek(0)
+
+                    async def replay() -> Message:
+                        chunk = body.read(READ_CHUNK_BYTES)
+                        return {
+                            "type": "http.request",
+                            "body": chunk,
+                            "more_body": body.tell() < size,
+                        }
+
+                    await self.app(scope, replay, send)
+        finally:
+            self.state.pending_transcriptions -= 1
+
 
 # Initialize the app
 app = FastAPI()
+app.state.pending_transcriptions = 0
+app.add_middleware(TranscriptionInputMiddleware, state=app.state)
 
 # allow all cors
 app.add_middleware(
@@ -38,30 +135,98 @@
 print("Model loaded!")
 
 
-@app.post("/transcribe/")
-async def transcription(file: UploadFile = File(...)):
-    try:
-        audio_bytes = await file.read()
+def decode_audio(audio_bytes: bytes) -> np.ndarray:
+    max_samples = int(MAX_AUDIO_SECONDS * SAMPLE_RATE)
+    with tempfile.TemporaryDirectory(prefix="typeagent-whisper-") as directory:
+        source = Path(directory) / "audio"
+        source.write_bytes(audio_bytes)
+        try:
+            result = subprocess.run(
+                [
+                    "ffmpeg",
+                    "-hide_banner",
+                    "-nostdin",
+                    "-loglevel",
+                    "fatal",
+                    "-max_alloc",
+                    str(64 * 1024 * 1024),
+                    "-threads",
+                    "1",
+                    "-protocol_whitelist",
+                    "file",
+                    "-i",
+                    str(source),
+                    "-map",
+                    "0:a:0",
+                    "-vn",
+                    "-sn",
+                    "-dn",
+                    "-ac",
+                    "1",
+                    "-ar",
+                    str(SAMPLE_RATE),
+                    "-t",
+                    str((max_samples + 1) / SAMPLE_RATE),
+                    "-fs",
+                    str((max_samples + 1) * 2),
+                    "-f",
+                    "s16le",
+                    "pipe:1",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                timeout=DECODE_TIMEOUT_SECONDS,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as error:
+            raise HTTPException(
+                422, "Audio decoding exceeded the processing time limit."
+            ) from error
+    if result.returncode != 0 or not result.stdout or len(result.stdout) % 2:
+        raise HTTPException(400, "Audio could not be decoded.")
+    if len(result.stdout) > max_samples * 2:
+        raise HTTPException(413, "The audio recording exceeds the duration limit.")
+    audio = np.frombuffer(result.stdout, dtype="<i2").astype(np.float32)
+    audio /= 32768.0
+    return audio
 
-        # Use pydub to handle different audio formats and convert audio
-        audio = AudioSegment.from_file(BytesIO(audio_bytes))
-        audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2)
 
-        # Convert data from 16 bit wide integers to floating point with a width of 32 bits.
-        # Clamp the audio stream frequency to a PCM wavelength compatible default of 32768hz max.
-        audio_np = (
-            np.frombuffer(audio.raw_data, dtype=np.int16).astype(np.float32) / 32768.0
-        )
+def transcribe_audio(audio_bytes: bytes) -> str:
+    segments, _ = model.transcribe(decode_audio(audio_bytes))
+    return "\n".join(segment.text for segment in segments)
 
-        # faster_whisper returns a generator. Iterate though it to get the transcription
-        segments, _ = model.transcribe(audio_np)
-        segments = list(segments)
-        transcription = "\n".join(i.text for i in segments)
 
-        return JSONResponse(content={"transcription": transcription}, status_code=200)
-    except Exception as e:
+@app.post("/transcribe/")
+async def transcription(file: UploadFile = File(...)) -> JSONResponse:
+    try:
+        audio_bytes = await file.read(MAX_UPLOAD_BYTES + 1)
+        if len(audio_bytes) > MAX_UPLOAD_BYTES:
+            raise HTTPException(413, "The audio file exceeds the upload size limit.")
+        worker = asyncio.create_task(asyncio.to_thread(transcribe_audio, audio_bytes))
+        try:
+            text = await asyncio.shield(worker)
+        except asyncio.CancelledError:
+            cleanup = asyncio.gather(worker, return_exceptions=True)
+            while not cleanup.done():
+                try:
+                    await asyncio.shield(cleanup)
+                except asyncio.CancelledError:
+                    continue
+            results = cleanup.result()
+            if isinstance(results[0], Exception):
+                logging.error("Cancelled transcription failed", exc_info=results[0])
+            raise
+        return JSONResponse(content={"transcription": text}, status_code=200)
+    except HTTPException as error:
+        logging.warning("Audio input rejected: %s", error.detail)
+        return JSONResponse(
+            content={"error": error.detail}, status_code=error.status_code
+        )
+    except Exception:
         logging.error("An error occurred during transcription", exc_info=True)
-        return JSONResponse(content={"error": "An internal error has occurred!"}, status_code=500)
+        return JSONResponse(
+            content={"error": "An internal error has occurred!"}, status_code=500
+        )
 
 
 if __name__ == "__main__":
diff --git a/python/stt/whisperService/requirements-test.txt b/python/stt/whisperService/requirements-test.txt
new file mode 100644
index 0000000000..ecfeefa239
--- /dev/null
+++ b/python/stt/whisperService/requirements-test.txt
@@ -0,0 +1,5 @@
+fastapi
+httpx
+numpy
+python-multipart
+uvicorn
diff --git a/python/stt/whisperService/requirements.txt b/python/stt/whisperService/requirements.txt
index 7fafb5b016..7210ff96d3 100644
--- a/python/stt/whisperService/requirements.txt
+++ b/python/stt/whisperService/requirements.txt
@@ -1,7 +1,6 @@
 pyaudio
 torch 
 numpy
-pydub
 fastapi
 uvicorn
 python-multipart
diff --git a/python/stt/whisperService/test_audio_limits.py b/python/stt/whisperService/test_audio_limits.py
new file mode 100644
index 0000000000..217674124d
--- /dev/null
+++ b/python/stt/whisperService/test_audio_limits.py
@@ -0,0 +1,308 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import asyncio
+import importlib.util
+import io
+from contextlib import redirect_stdout
+from pathlib import Path
+import subprocess
+import threading
+import types
+import unittest
+from unittest.mock import patch
+import wave
+
+import httpx
+import numpy as np
+
+
+def audio_bytes(samples: int = 320) -> bytes:
+    output = io.BytesIO()
+    with wave.open(output, "wb") as audio:
+        audio.setnchannels(1)
+        audio.setsampwidth(2)
+        audio.setframerate(16000)
+        audio.writeframes(np.full(samples, 16384, dtype="<i2").tobytes())
+    return output.getvalue()
+
+
+class Model:
+    def __init__(self) -> None:
+        self.inputs: list[np.ndarray] = []
+        self.started = threading.Event()
+        self.release = threading.Event()
+        self.block = False
+
+    def transcribe(self, audio: np.ndarray):
+        self.inputs.append(audio.copy())
+        self.started.set()
+        if self.block and not self.release.wait(5):
+            raise RuntimeError("Test transcription was not released")
+        return iter([types.SimpleNamespace(text="hello")]), None
+
+
+def load_service(model: Model):
+    torch = types.ModuleType("torch")
+    torch.cuda = types.SimpleNamespace(is_available=lambda: False)
+    whisper = types.ModuleType("faster_whisper")
+    whisper.WhisperModel = lambda *args, **kwargs: model
+
+    spec = importlib.util.spec_from_file_location(
+        "whisper_service_test", Path(__file__).with_name("faster-whisper.py")
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError("Unable to load the service")
+    service = importlib.util.module_from_spec(spec)
+    with patch.dict(
+        "sys.modules", {"torch": torch, "faster_whisper": whisper}
+    ), redirect_stdout(io.StringIO()):
+        spec.loader.exec_module(service)
+    return service
+
+
+class AudioLimitsTests(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self) -> None:
+        self.model = Model()
+        self.service = load_service(self.model)
+        self.service.MAX_UPLOAD_BYTES = len(audio_bytes())
+        self.service.MAX_REQUEST_BYTES = self.service.MAX_UPLOAD_BYTES + 65536
+        self.service.MAX_AUDIO_SECONDS = 0.02
+        self.client = httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=self.service.app),
+            base_url="http://test",
+        )
+
+    async def asyncTearDown(self) -> None:
+        self.model.release.set()
+        await self.client.aclose()
+
+    async def upload(self, content: bytes):
+        return await self.client.post(
+            "/transcribe/",
+            files={"file": ("recording.wav", content, "audio/wav")},
+        )
+
+    async def test_exact_upload_and_duration_limits_preserve_output(self) -> None:
+        response = await self.upload(audio_bytes())
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"transcription": "hello"})
+        self.assertEqual(len(self.model.inputs), 1)
+        self.assertEqual(self.model.inputs[0].dtype, np.float32)
+        np.testing.assert_array_equal(self.model.inputs[0], np.full(320, 0.5))
+
+    async def test_upload_one_byte_over_limit_stops_before_inference(self) -> None:
+        response = await self.upload(audio_bytes() + b"x")
+        self.assertEqual(response.status_code, 413)
+        self.assertIn("error", response.json())
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_decoded_audio_one_sample_over_limit_is_rejected(self) -> None:
+        self.service.MAX_UPLOAD_BYTES = 4096
+        response = await self.upload(audio_bytes(321))
+        self.assertEqual(response.status_code, 413)
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_audio_below_duration_limit_is_accepted(self) -> None:
+        response = await self.upload(audio_bytes(319))
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(self.model.inputs[0]), 319)
+
+    async def test_compressed_audio_is_bounded_by_decoded_samples(self) -> None:
+        compressed = subprocess.run(
+            [
+                "ffmpeg", "-hide_banner", "-loglevel", "error",
+                "-f", "wav", "-i", "pipe:0", "-c:a", "flac",
+                "-f", "flac", "pipe:1",
+            ],
+            input=audio_bytes(16000),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            timeout=10,
+        ).stdout
+        self.assertLess(len(compressed), len(audio_bytes(16000)))
+        self.service.MAX_UPLOAD_BYTES = len(compressed)
+        response = await self.upload(compressed)
+        self.assertEqual(response.status_code, 413)
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_decoder_timeout_is_reported_and_releases_capacity(self) -> None:
+        with patch.object(
+            self.service.subprocess,
+            "run",
+            side_effect=subprocess.TimeoutExpired("ffmpeg", 30),
+        ):
+            response = await self.upload(audio_bytes())
+        self.assertEqual(response.status_code, 422)
+        self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+        self.assertEqual(self.model.inputs, [])
+        self.assertEqual((await self.upload(audio_bytes())).status_code, 200)
+
+    async def test_invalid_audio_is_an_explicit_input_error(self) -> None:
+        response = await self.upload(b"not audio")
+        self.assertEqual(response.status_code, 400)
+        self.assertIn("error", response.json())
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_declared_request_limit_rejects_before_reading_body(self) -> None:
+        self.service.MAX_REQUEST_BYTES = 100
+        response = await self.client.post(
+            "/transcribe/",
+            content=b"x" * 101,
+            headers={"origin": "http://example.test"},
+        )
+        self.assertEqual(response.status_code, 413)
+        self.assertIsNotNone(response.headers.get("access-control-allow-origin"))
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_chunked_request_limit_does_not_depend_on_content_length(self) -> None:
+        self.service.MAX_REQUEST_BYTES = 100
+
+        async def content():
+            yield b"x" * 50
+            yield b"x" * 51
+
+        response = await self.client.post("/transcribe/", content=content())
+        self.assertEqual(response.status_code, 413)
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_stalled_upload_times_out_and_releases_waiting_request(self) -> None:
+        self.service.UPLOAD_TIMEOUT_SECONDS = 0.25
+        started = asyncio.Event()
+
+        async def content():
+            started.set()
+            await asyncio.Event().wait()
+            yield b""
+
+        tasks = [asyncio.create_task(self.client.post(
+            "/transcribe/",
+            content=content(),
+            headers={"origin": "http://example.test"},
+        ))]
+        try:
+            await asyncio.wait_for(started.wait(), 2)
+            tasks.append(asyncio.create_task(self.upload(audio_bytes())))
+            for _ in range(100):
+                if self.service.app.state.pending_transcriptions == 2:
+                    break
+                await asyncio.sleep(0.001)
+            self.assertEqual(self.service.app.state.pending_transcriptions, 2)
+            self.assertEqual((await self.upload(audio_bytes())).status_code, 503)
+            stalled, waiting = await asyncio.wait_for(asyncio.gather(*tasks), 5)
+            self.assertEqual(stalled.status_code, 408)
+            self.assertEqual(stalled.json(), {
+                "error": "The audio upload exceeded the time limit."
+            })
+            self.assertIsNotNone(
+                stalled.headers.get("access-control-allow-origin")
+            )
+            self.assertEqual(waiting.status_code, 200)
+            self.assertEqual(waiting.json(), {"transcription": "hello"})
+            self.assertEqual(len(self.model.inputs), 1)
+            self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+        finally:
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def test_upload_stalled_after_a_chunk_times_out(self) -> None:
+        self.service.UPLOAD_TIMEOUT_SECONDS = 0.05
+
+        async def content():
+            yield b"unfinished audio"
+            await asyncio.Event().wait()
+
+        response = await asyncio.wait_for(
+            self.client.post("/transcribe/", content=content()), 2
+        )
+        self.assertEqual(response.status_code, 408)
+        self.assertEqual(response.json(), {
+            "error": "The audio upload exceeded the time limit."
+        })
+        self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+        self.assertEqual(self.model.inputs, [])
+        self.assertEqual((await self.upload(audio_bytes())).status_code, 200)
+
+    async def test_upload_timeout_bounds_total_time_not_each_chunk(self) -> None:
+        self.service.UPLOAD_TIMEOUT_SECONDS = 0.1
+        sent_chunks = 0
+
+        async def content():
+            nonlocal sent_chunks
+            for _ in range(10):
+                await asyncio.sleep(0.025)
+                sent_chunks += 1
+                yield b"x"
+
+        response = await asyncio.wait_for(
+            self.client.post("/transcribe/", content=content()), 2
+        )
+        self.assertEqual(response.status_code, 408)
+        self.assertLess(sent_chunks, 10)
+        self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+        self.assertEqual(self.model.inputs, [])
+
+    async def test_one_waiting_request_and_explicit_busy_response(self) -> None:
+        self.service.UPLOAD_TIMEOUT_SECONDS = 0.1
+        self.model.block = True
+        first = asyncio.create_task(self.upload(audio_bytes()))
+        try:
+            started = await asyncio.to_thread(self.model.started.wait, 2)
+            self.assertTrue(started)
+            second = asyncio.create_task(self.upload(audio_bytes()))
+            try:
+                for _ in range(100):
+                    if self.service.app.state.pending_transcriptions == 2:
+                        break
+                    await asyncio.sleep(0.01)
+                self.assertEqual(self.service.app.state.pending_transcriptions, 2)
+                response = await self.upload(audio_bytes())
+                self.assertEqual(response.status_code, 503)
+                self.assertEqual(response.headers["retry-after"], "1")
+                self.assertEqual(len(self.model.inputs), 1)
+                await asyncio.sleep(0.15)
+                self.assertFalse(first.done())
+                self.assertFalse(second.done())
+                self.model.release.set()
+                responses = await asyncio.gather(first, second)
+                self.assertTrue(
+                    all(result.status_code == 200 for result in responses)
+                )
+                self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+            finally:
+                self.model.release.set()
+                await second
+        finally:
+            self.model.release.set()
+            await first
+
+    async def test_cancelled_request_keeps_capacity_until_worker_finishes(self) -> None:
+        self.model.block = True
+        first = asyncio.create_task(self.upload(audio_bytes()))
+        self.assertTrue(await asyncio.to_thread(self.model.started.wait, 2))
+        first.cancel()
+        second = asyncio.create_task(self.upload(audio_bytes()))
+        try:
+            for _ in range(100):
+                if self.service.app.state.pending_transcriptions == 2:
+                    break
+                await asyncio.sleep(0.01)
+            self.assertEqual(self.service.app.state.pending_transcriptions, 2)
+            first.cancel()
+            await asyncio.sleep(0.01)
+            self.assertEqual((await self.upload(audio_bytes())).status_code, 503)
+            self.assertEqual(len(self.model.inputs), 1)
+            self.model.release.set()
+            with self.assertRaises(asyncio.CancelledError):
+                await first
+            self.assertEqual((await second).status_code, 200)
+            self.assertEqual(self.service.app.state.pending_transcriptions, 0)
+        finally:
+            self.model.release.set()
+            await asyncio.gather(first, second, return_exceptions=True)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/ts/examples/whisperClient/package.json b/ts/examples/whisperClient/package.json
index ab341d6187..880642b396 100644
--- a/ts/examples/whisperClient/package.json
+++ b/ts/examples/whisperClient/package.json
@@ -23,6 +23,7 @@
     "webpack": "webpack"
   },
   "dependencies": {
+    "@typeagent/common-utils": "workspace:*",
     "chalk": "^5.4.1",
     "debug": "^4.4.0"
   },
diff --git a/ts/examples/whisperClient/public/index.html b/ts/examples/whisperClient/public/index.html
index f47e69f452..e444780b68 100644
--- a/ts/examples/whisperClient/public/index.html
+++ b/ts/examples/whisperClient/public/index.html
@@ -9,11 +9,16 @@
   <body>
     <button id="record">Start Capture</button>
     <div id="transcriptionResult"></div>
-    <script src="index.js"></script>
+    <script src="bundle.js"></script>
     <script>
       document.addEventListener("DOMContentLoaded", (event) => {
         const whisperClient = new WhisperRecognizer();
 
+        whisperClient.onError((error) => {
+          transcriptionResult.innerText = error.message;
+          record.disabled = false;
+        });
+
         whisperClient.onRecognizing((data) => {
           transcriptionResult.innerText = data.text;
         });
diff --git a/ts/examples/whisperClient/src/index.ts b/ts/examples/whisperClient/src/index.ts
index d08ffd4499..d373a3563d 100644
--- a/ts/examples/whisperClient/src/index.ts
+++ b/ts/examples/whisperClient/src/index.ts
@@ -1,13 +1,18 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+import { getLocalWhisperTranscription } from "@typeagent/common-utils";
+
 class WhisperRecognizer {
     private audioContext: AudioContext | null = null;
     private mediaStreamSource: MediaStreamAudioSourceNode | null = null;
     private analyser: AnalyserNode | null = null;
     private mediaRecorder: MediaRecorder | null = null;
-    private silenceTimeout: any = null;
+    private silenceTimeout: ReturnType<typeof setTimeout> | null = null;
+    private recordingId = 0;
     private awaitingResult = false;
+    private transcriptionFailed = false;
+    private errorCallback: ((error: Error) => void) | undefined;
     private recognizingCallback:
         | ((result: { text: string }) => void)
         | undefined;
@@ -27,6 +32,10 @@ class WhisperRecognizer {
 
             this.mediaRecorder = new MediaRecorder(stream);
             this.mediaRecorder.ondataavailable = async (e) => {
+                const recordingId = this.recordingId;
+                if (this.transcriptionFailed) {
+                    return;
+                }
                 this.audioChunks.push(e.data);
 
                 if (
@@ -36,15 +45,43 @@ class WhisperRecognizer {
                     const blob = new Blob(this.audioChunks, {
                         type: "audio/mpeg-3",
                     });
-                    const text = await this.getTranscription(blob);
-                    if (this.mediaRecorder!.state === "inactive") {
-                        if (this.recognizedCallback) {
-                            this.recognizedCallback({ text });
+                    try {
+                        const text = await this.getTranscription(
+                            blob,
+                            recordingId,
+                        );
+                        if (
+                            recordingId !== this.recordingId ||
+                            this.transcriptionFailed
+                        ) {
+                            return;
+                        }
+                        if (this.mediaRecorder!.state === "inactive") {
+                            if (this.recognizedCallback) {
+                                this.recognizedCallback({ text });
+                            }
+                        } else {
+                            if (this.recognizingCallback) {
+                                this.recognizingCallback({ text });
+                            }
                         }
-                    } else {
-                        if (this.recognizingCallback) {
-                            this.recognizingCallback({ text });
+                    } catch (error) {
+                        if (
+                            recordingId !== this.recordingId ||
+                            this.transcriptionFailed
+                        ) {
+                            return;
                         }
+                        this.transcriptionFailed = true;
+                        if (this.mediaRecorder?.state === "recording") {
+                            this.mediaRecorder.stop();
+                        }
+                        const failure =
+                            error instanceof Error
+                                ? error
+                                : new Error(String(error));
+                        console.error("Local transcription failed:", failure);
+                        this.errorCallback?.(failure);
                     }
                 }
             };
@@ -52,9 +89,16 @@ class WhisperRecognizer {
     }
 
     startRecording() {
+        this.recordingId++;
         this.audioChunks = [];
+        this.awaitingResult = false;
+        this.transcriptionFailed = false;
+        if (this.silenceTimeout) {
+            clearTimeout(this.silenceTimeout);
+            this.silenceTimeout = null;
+        }
         this.mediaRecorder?.start(200);
-        this.checkForSilence();
+        this.checkForSilence(this.recordingId);
     }
 
     stopRecording() {
@@ -69,21 +113,32 @@ class WhisperRecognizer {
         this.recognizedCallback = callback;
     }
 
-    private async getTranscription(blob: Blob): Promise<string> {
-        this.awaitingResult = true;
-        const formData = new FormData();
-        formData.append("file", blob);
-        const response = await fetch("http://localhost:8001/transcribe", {
-            method: "POST",
-            body: formData,
-        });
+    onError(callback: (error: Error) => void) {
+        this.errorCallback = callback;
+    }
 
-        const responseBody = await response.json();
-        this.awaitingResult = false;
-        return responseBody.transcription;
+    private async getTranscription(
+        blob: Blob,
+        recordingId: number,
+    ): Promise<string> {
+        this.awaitingResult = true;
+        try {
+            return await getLocalWhisperTranscription(blob);
+        } finally {
+            if (recordingId === this.recordingId) {
+                this.awaitingResult = false;
+            }
+        }
     }
 
-    private checkForSilence() {
+    private checkForSilence(recordingId: number) {
+        if (
+            recordingId !== this.recordingId ||
+            this.transcriptionFailed ||
+            this.mediaRecorder?.state !== "recording"
+        ) {
+            return;
+        }
         const bufferLength = this.analyser!.fftSize;
         const amplitudeArray = new Float32Array(bufferLength || 0);
         const silenceDuration = 1000;
@@ -94,12 +149,14 @@ class WhisperRecognizer {
         const volume = this.getVolume(amplitudeArray);
 
         if (volume < silenceThreshold) {
-            if (
-                !this.silenceTimeout &&
-                this.mediaRecorder!.state !== "inactive"
-            ) {
+            if (!this.silenceTimeout) {
                 this.silenceTimeout = setTimeout(() => {
-                    this.mediaRecorder?.stop();
+                    if (recordingId !== this.recordingId) {
+                        return;
+                    }
+                    if (this.mediaRecorder?.state === "recording") {
+                        this.mediaRecorder.stop();
+                    }
                     this.silenceTimeout = null;
                 }, silenceDuration);
             }
@@ -110,7 +167,7 @@ class WhisperRecognizer {
             }
         }
 
-        requestAnimationFrame(() => this.checkForSilence());
+        requestAnimationFrame(() => this.checkForSilence(recordingId));
     }
 
     private getVolume(amplitudeArray: Float32Array) {
@@ -123,3 +180,5 @@ class WhisperRecognizer {
         return volume;
     }
 }
+
+Object.assign(window, { WhisperRecognizer });
diff --git a/ts/packages/shell/playwright.config.ts b/ts/packages/shell/playwright.config.ts
index 1167018fb3..fc0efa5cad 100644
--- a/ts/packages/shell/playwright.config.ts
+++ b/ts/packages/shell/playwright.config.ts
@@ -16,8 +16,13 @@ import { defineConfig, devices } from "@playwright/test";
  */
 export default defineConfig({
     testDir: "./test",
-    /* Exclude Jest unit tests from Playwright test discovery */
-    testIgnore: /\/(partialCompletion|unit)\//,
+    /* Exclude unit tests from Playwright test discovery */
+    testIgnore: [
+        /\/partialCompletion\//,
+        /\/unit\//,
+        /\/renderer\/localWhisperClient\.spec\.ts$/,
+        /\/inlinePageCapture\.test\.mjs$/,
+    ],
     /* Run tests sequentially otherwise the client will complain about locked session file */
     fullyParallel: false,
     /* Fail the build on CI if you accidentally left test.only in the source code. */
diff --git a/ts/packages/shell/src/renderer/src/localWhisperClient.ts b/ts/packages/shell/src/renderer/src/localWhisperClient.ts
index 69ba0f6153..6f816f2c13 100644
--- a/ts/packages/shell/src/renderer/src/localWhisperClient.ts
+++ b/ts/packages/shell/src/renderer/src/localWhisperClient.ts
@@ -1,14 +1,20 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+import { getLocalWhisperTranscription } from "@typeagent/common-utils";
+
 export class WhisperRecognizer {
     private audioContext: AudioContext | null = null;
     private mediaStreamSource: MediaStreamAudioSourceNode | null = null;
     private analyser: AnalyserNode | null = null;
     private mediaRecorder: MediaRecorder | null = null;
-    private silenceTimeout: any = null;
+    private silenceTimeout: ReturnType<typeof setTimeout> | null = null;
+    private recordingId = 0;
     private awaitingResult = false;
     private recognizedFired = false;
+    private transcriptionFailed = false;
+    private errorCallback: (error: Error) => void = (error) =>
+        console.error(error);
     private recognizingCallback:
         | ((result: { text: string }) => void)
         | undefined;
@@ -19,11 +25,7 @@ export class WhisperRecognizer {
     private stream?: MediaStream;
     private disposed = false;
     private animationFrame?: number;
-    private httpController?: AbortController;
-    private errorCallback: (message: string) => void = (message) =>
-        console.error(message);
-
-    constructor() {}
+    private httpController: AbortController | undefined;
 
     async initialize() {
         const stream = await navigator.mediaDevices.getUserMedia({
@@ -43,9 +45,10 @@ export class WhisperRecognizer {
         this.mediaStreamSource.connect(this.analyser);
 
         this.mediaRecorder = new MediaRecorder(stream);
-        this.mediaRecorder.ondataavailable = async (e) => {
-            if (this.disposed) return;
-            this.audioChunks.push(e.data);
+        this.mediaRecorder.ondataavailable = async (event) => {
+            if (this.disposed || this.transcriptionFailed) return;
+            const recordingId = this.recordingId;
+            this.audioChunks.push(event.data);
 
             if (
                 this.mediaRecorder!.state === "inactive" ||
@@ -57,28 +60,52 @@ export class WhisperRecognizer {
                 this.httpController?.abort();
                 const controller = new AbortController();
                 this.httpController = controller;
-                let text: string;
+                this.awaitingResult = true;
+
                 try {
-                    text = await this.getTranscription(blob, controller.signal);
+                    const text = await this.getTranscription(
+                        blob,
+                        controller.signal,
+                    );
+                    if (
+                        controller.signal.aborted ||
+                        this.disposed ||
+                        recordingId !== this.recordingId ||
+                        this.transcriptionFailed
+                    ) {
+                        return;
+                    }
+                    if (this.mediaRecorder!.state === "inactive") {
+                        if (this.recognizedCallback && !this.recognizedFired) {
+                            this.recognizedFired = true;
+                            this.recognizedCallback({ text });
+                        }
+                    } else {
+                        this.recognizingCallback?.({ text });
+                    }
                 } catch (error) {
-                    if (!controller.signal.aborted) {
-                        this.errorCallback(
-                            error instanceof Error
-                                ? error.message
-                                : String(error),
-                        );
+                    if (
+                        controller.signal.aborted ||
+                        this.disposed ||
+                        recordingId !== this.recordingId ||
+                        this.transcriptionFailed
+                    ) {
+                        return;
                     }
-                    return;
-                }
-                if (controller.signal.aborted || this.disposed) return;
-                if (this.mediaRecorder!.state === "inactive") {
-                    if (this.recognizedCallback && !this.recognizedFired) {
-                        this.recognizedCallback({ text });
-                        this.recognizedFired = true;
+                    this.transcriptionFailed = true;
+                    if (this.mediaRecorder?.state === "recording") {
+                        this.mediaRecorder.stop();
                     }
-                } else {
-                    if (this.recognizingCallback) {
-                        this.recognizingCallback({ text });
+                    const failure =
+                        error instanceof Error
+                            ? error
+                            : new Error(String(error));
+                    console.error("Local transcription failed:", failure);
+                    this.errorCallback(failure);
+                } finally {
+                    if (this.httpController === controller) {
+                        this.httpController = undefined;
+                        this.awaitingResult = false;
                     }
                 }
             }
@@ -87,18 +114,28 @@ export class WhisperRecognizer {
 
     startRecording() {
         if (this.disposed || this.mediaRecorder?.state !== "inactive") return;
+        this.recordingId++;
+        this.httpController?.abort();
+        this.httpController = undefined;
         this.audioChunks = [];
+        this.awaitingResult = false;
         this.recognizedFired = false;
-        this.mediaRecorder?.start(200);
-        this.checkForSilence();
+        this.transcriptionFailed = false;
+        if (this.silenceTimeout !== null) {
+            clearTimeout(this.silenceTimeout);
+            this.silenceTimeout = null;
+        }
+        this.mediaRecorder.start(200);
+        this.checkForSilence(this.recordingId);
     }
 
     stopRecording() {
-        if (this.mediaRecorder?.state === "recording")
+        if (this.mediaRecorder?.state === "recording") {
             this.mediaRecorder.stop();
+        }
     }
 
-    onError(callback: (message: string) => void) {
+    onError(callback: (error: Error) => void) {
         this.errorCallback = callback;
     }
 
@@ -107,8 +144,9 @@ export class WhisperRecognizer {
         this.disposed = true;
         this.httpController?.abort();
         this.stopRecording();
-        if (this.animationFrame !== undefined)
+        if (this.animationFrame !== undefined) {
             cancelAnimationFrame(this.animationFrame);
+        }
         if (this.silenceTimeout !== null) clearTimeout(this.silenceTimeout);
         this.stream?.getTracks().forEach((track) => track.stop());
         this.mediaStreamSource?.disconnect();
@@ -118,7 +156,9 @@ export class WhisperRecognizer {
                 ?.close()
                 .catch((error: unknown) =>
                     this.errorCallback(
-                        error instanceof Error ? error.message : String(error),
+                        error instanceof Error
+                            ? error
+                            : new Error(String(error)),
                     ),
                 );
         }
@@ -136,26 +176,18 @@ export class WhisperRecognizer {
         blob: Blob,
         signal: AbortSignal,
     ): Promise<string> {
-        this.awaitingResult = true;
-        const formData = new FormData();
-        formData.append("file", blob);
-        const response = await fetch("http://localhost:8001/transcribe", {
-            method: "POST",
-            body: formData,
-            signal,
-        });
-        if (!response.ok)
-            throw new Error(`Whisper returned HTTP ${response.status}.`);
-
-        const responseBody = await response.json();
-        this.awaitingResult = false;
-        if (typeof responseBody.transcription !== "string")
-            throw new Error("Whisper returned an invalid transcript.");
-        return responseBody.transcription;
+        return getLocalWhisperTranscription(blob, signal);
     }
 
-    private checkForSilence() {
-        if (this.disposed || this.mediaRecorder?.state !== "recording") return;
+    private checkForSilence(recordingId: number) {
+        if (
+            this.disposed ||
+            recordingId !== this.recordingId ||
+            this.transcriptionFailed ||
+            this.mediaRecorder?.state !== "recording"
+        ) {
+            return;
+        }
         const bufferLength = this.analyser!.fftSize;
         const amplitudeArray = new Float32Array(bufferLength || 0);
         const silenceDuration = 1000;
@@ -166,22 +198,29 @@ export class WhisperRecognizer {
         const volume = this.getVolume(amplitudeArray);
 
         if (volume < silenceThreshold) {
-            if (!this.silenceTimeout) {
-                this.silenceTimeout = setTimeout(() => {
-                    this.stopRecording();
+            if (this.silenceTimeout === null) {
+                const timeout = setTimeout(() => {
+                    if (this.silenceTimeout !== timeout) return;
                     this.silenceTimeout = null;
+                    if (
+                        recordingId === this.recordingId &&
+                        this.mediaRecorder?.state === "recording"
+                    ) {
+                        this.mediaRecorder.stop();
+                    }
                 }, silenceDuration);
+                this.silenceTimeout = timeout;
             }
-        } else {
-            if (this.silenceTimeout) {
-                clearTimeout(this.silenceTimeout);
-                this.silenceTimeout = null;
-            }
+        } else if (this.silenceTimeout !== null) {
+            clearTimeout(this.silenceTimeout);
+            this.silenceTimeout = null;
         }
 
-        this.animationFrame = requestAnimationFrame(() =>
-            this.checkForSilence(),
-        );
+        this.animationFrame = requestAnimationFrame(() => {
+            if (recordingId === this.recordingId) {
+                this.checkForSilence(recordingId);
+            }
+        });
     }
 
     private getVolume(amplitudeArray: Float32Array) {
diff --git a/ts/packages/shell/src/renderer/src/speech.ts b/ts/packages/shell/src/renderer/src/speech.ts
index 759f5e6104..bada54a91e 100644
--- a/ts/packages/shell/src/renderer/src/speech.ts
+++ b/ts/packages/shell/src/renderer/src/speech.ts
@@ -115,7 +115,7 @@ export function recognizeOnce(
 ): () => void {
     if (useLocalWhisper) {
         const reco = new WhisperRecognizer();
-        reco.onError(onError);
+        reco.onError((error) => onError(`[ERROR: ${error.message}]`));
 
         reco.onRecognizing((data) => {
             onRecognizing(data.text);
@@ -208,7 +208,9 @@ export class ContinousSpeechRecognizer {
 
         if (useWhisper) {
             this.whisperRecognizer = new WhisperRecognizer();
-            this.whisperRecognizer.onError(onError);
+            this.whisperRecognizer.onError((error) =>
+                this.onError(`[ERROR: ${error.message}]`),
+            );
 
             this.whisperRecognizer.onRecognizing((data) => {
                 this.onRecognizing(data.text);
diff --git a/ts/packages/shell/test/renderer/localWhisperClient.spec.ts b/ts/packages/shell/test/renderer/localWhisperClient.spec.ts
new file mode 100644
index 0000000000..21510896a3
--- /dev/null
+++ b/ts/packages/shell/test/renderer/localWhisperClient.spec.ts
@@ -0,0 +1,270 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { jest } from "@jest/globals";
+import { createPromiseWithResolvers } from "@typeagent/common-utils";
+import { WhisperRecognizer } from "../../src/renderer/src/localWhisperClient.js";
+
+class MockMediaRecorder {
+    state: RecordingState = "inactive";
+    ondataavailable: ((event: { data: Blob }) => Promise<void>) | undefined;
+    start = jest.fn(() => {
+        this.state = "recording";
+    });
+    stop = jest.fn(() => {
+        this.state = "inactive";
+    });
+
+    emitData(data = new Blob(["audio"])) {
+        if (!this.ondataavailable) {
+            throw new Error("The recorder has not been initialized.");
+        }
+        return this.ondataavailable({ data });
+    }
+}
+
+const originalFetch = globalThis.fetch;
+const originalGlobals = [
+    "AudioContext",
+    "MediaRecorder",
+    "navigator",
+    "requestAnimationFrame",
+].map((name): [string, PropertyDescriptor | undefined] => [
+    name,
+    Object.getOwnPropertyDescriptor(globalThis, name),
+]);
+
+let recognizer: WhisperRecognizer;
+let recorder: MockMediaRecorder;
+let fetchMock: jest.MockedFunction<typeof fetch>;
+let animationFrame: jest.MockedFunction<typeof requestAnimationFrame>;
+let recognizing: jest.MockedFunction<(result: { text: string }) => void>;
+let recognized: jest.MockedFunction<(result: { text: string }) => void>;
+let onError: jest.MockedFunction<(error: Error) => void>;
+let amplitude: number;
+
+beforeEach(async () => {
+    jest.useFakeTimers();
+    jest.spyOn(console, "error").mockImplementation(() => {});
+    amplitude = 1;
+    recorder = new MockMediaRecorder();
+    fetchMock = jest.fn<typeof fetch>();
+    animationFrame = jest.fn<typeof requestAnimationFrame>().mockReturnValue(1);
+    globalThis.fetch = fetchMock;
+    Object.defineProperties(globalThis, {
+        AudioContext: {
+            configurable: true,
+            value: class {
+                createMediaStreamSource() {
+                    return { connect() {} };
+                }
+                createAnalyser() {
+                    return {
+                        fftSize: 1,
+                        minDecibels: -100,
+                        getFloatTimeDomainData(data: Float32Array) {
+                            data.fill(amplitude);
+                        },
+                    };
+                }
+            },
+        },
+        MediaRecorder: {
+            configurable: true,
+            value: jest.fn(() => recorder),
+        },
+        navigator: {
+            configurable: true,
+            value: {
+                mediaDevices: {
+                    getUserMedia: async () => ({}),
+                },
+            },
+        },
+        requestAnimationFrame: {
+            configurable: true,
+            value: animationFrame,
+        },
+    });
+    recognizing = jest.fn();
+    recognized = jest.fn();
+    onError = jest.fn();
+    recognizer = new WhisperRecognizer();
+    recognizer.onRecognizing(recognizing);
+    recognizer.onRecognized(recognized);
+    recognizer.onError(onError);
+    await recognizer.initialize();
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    for (const [name, descriptor] of originalGlobals) {
+        if (descriptor) {
+            Object.defineProperty(globalThis, name, descriptor);
+        } else {
+            Reflect.deleteProperty(globalThis, name);
+        }
+    }
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+});
+
+it.each([
+    { final: false, outcome: "success" },
+    { final: false, outcome: "error" },
+    { final: true, outcome: "success" },
+    { final: true, outcome: "error" },
+])(
+    "ignores an earlier recording's $outcome (final: $final)",
+    async ({ final, outcome }) => {
+        const previous = createPromiseWithResolvers<Response>();
+        const current = createPromiseWithResolvers<Response>();
+        fetchMock
+            .mockReturnValueOnce(previous.promise)
+            .mockReturnValueOnce(current.promise);
+        recognizer.startRecording();
+        if (final) {
+            recognizer.stopRecording();
+        }
+        const staleResult = recorder.emitData(new Blob(["old audio"]));
+        if (!final) {
+            recognizer.stopRecording();
+        }
+        recognizer.startRecording();
+        const activeResult = recorder.emitData(new Blob(["new audio"]));
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        const body = fetchMock.mock.calls[1]?.[1]?.body;
+        if (!(body instanceof FormData)) {
+            throw new Error("Expected a multipart transcription request.");
+        }
+        const audio = body.get("file");
+        if (!(audio instanceof Blob)) {
+            throw new Error("Expected an audio file in the request.");
+        }
+        expect(await audio.text()).toBe("new audio");
+
+        if (outcome === "error") {
+            previous.reject(new Error("Previous recording failed."));
+        } else {
+            previous.resolve(
+                new Response(JSON.stringify({ transcription: "old text" })),
+            );
+        }
+        await staleResult;
+        expect(recorder.state).toBe("recording");
+        expect(recorder.stop).toHaveBeenCalledTimes(1);
+        expect(recognizing).not.toHaveBeenCalled();
+        expect(recognized).not.toHaveBeenCalled();
+        expect(onError).not.toHaveBeenCalled();
+        expect(console.error).not.toHaveBeenCalled();
+
+        await recorder.emitData();
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        current.resolve(
+            new Response(JSON.stringify({ transcription: "new text" })),
+        );
+        await activeResult;
+        expect(recognizing).toHaveBeenCalledWith({ text: "new text" });
+        expect(onError).not.toHaveBeenCalled();
+    },
+);
+
+it("reports a current failure, stops its recording, and permits a retry", async () => {
+    const failure = new Error("The audio upload exceeded the time limit.");
+    fetchMock.mockRejectedValueOnce(failure);
+    recognizer.startRecording();
+    await recorder.emitData();
+    expect(recorder.state).toBe("inactive");
+    expect(recorder.stop).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(failure);
+    expect(console.error).toHaveBeenCalledWith(
+        "Local transcription failed:",
+        failure,
+    );
+    await recorder.emitData();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+
+    fetchMock.mockResolvedValueOnce(
+        new Response(JSON.stringify({ transcription: "retry" })),
+    );
+    recognizer.startRecording();
+    await recorder.emitData();
+    expect(recognizing).toHaveBeenCalledWith({ text: "retry" });
+    expect(recorder.state).toBe("recording");
+    expect(onError).toHaveBeenCalledTimes(1);
+});
+
+it("reports only one failure when interim and final requests both fail", async () => {
+    const interim = createPromiseWithResolvers<Response>();
+    const final = createPromiseWithResolvers<Response>();
+    fetchMock
+        .mockReturnValueOnce(interim.promise)
+        .mockReturnValueOnce(final.promise);
+    recognizer.startRecording();
+    const interimResult = recorder.emitData();
+    recognizer.stopRecording();
+    const finalResult = recorder.emitData();
+    interim.reject(new Error("Transcription failed."));
+    await interimResult;
+    const finalFailure = new Error("Final transcription failed.");
+    final.reject(finalFailure);
+    await finalResult;
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(finalFailure);
+    expect(console.error).toHaveBeenCalledTimes(1);
+    expect(recognizing).not.toHaveBeenCalled();
+    expect(recognized).not.toHaveBeenCalled();
+});
+
+it("preserves interim text and emits the final result only once", async () => {
+    fetchMock.mockImplementation(
+        async () => new Response(JSON.stringify({ transcription: "hello" })),
+    );
+    recognizer.startRecording();
+    await recorder.emitData();
+    expect(recognizing).toHaveBeenCalledWith({ text: "hello" });
+    expect(recognized).not.toHaveBeenCalled();
+    recognizer.stopRecording();
+    await recorder.emitData();
+    await recorder.emitData();
+    expect(recognized).toHaveBeenCalledTimes(1);
+    expect(recognized).toHaveBeenCalledWith({ text: "hello" });
+});
+
+it("allows the final callback to start the next recording", async () => {
+    fetchMock.mockImplementation(
+        async () => new Response(JSON.stringify({ transcription: "hello" })),
+    );
+    recognized.mockImplementation(() => recognizer.startRecording());
+    recognizer.startRecording();
+    recognizer.stopRecording();
+    await recorder.emitData();
+    recognizer.stopRecording();
+    await recorder.emitData();
+    expect(recognized).toHaveBeenCalledTimes(2);
+});
+
+it("does not let an earlier silence timer or animation loop stop a retry", () => {
+    amplitude = 0;
+    recognizer.startRecording();
+    const previousFrame = animationFrame.mock.calls[0]?.[0];
+    if (!previousFrame) {
+        throw new Error("Expected a silence-check animation frame.");
+    }
+    recognizer.stopRecording();
+    amplitude = 1;
+    recognizer.startRecording();
+    previousFrame(0);
+    expect(animationFrame).toHaveBeenCalledTimes(2);
+    jest.advanceTimersByTime(1000);
+    expect(recorder.state).toBe("recording");
+    expect(recorder.stop).toHaveBeenCalledTimes(1);
+});
+
+it("still stops the current recording after silence", () => {
+    amplitude = 0;
+    recognizer.startRecording();
+    jest.advanceTimersByTime(1000);
+    expect(recorder.state).toBe("inactive");
+    expect(recorder.stop).toHaveBeenCalledTimes(1);
+});
diff --git a/ts/packages/shell/test/renderer/tsconfig.json b/ts/packages/shell/test/renderer/tsconfig.json
new file mode 100644
index 0000000000..43cecd22d1
--- /dev/null
+++ b/ts/packages/shell/test/renderer/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "../..",
+    "outDir": "../../dist",
+    "lib": ["es2021", "dom"],
+    "types": ["node", "jest"]
+  },
+  "include": ["./*.ts", "../../src/renderer/src/localWhisperClient.ts"]
+}
diff --git a/ts/packages/shell/test/tsconfig.json b/ts/packages/shell/test/tsconfig.json
index d22e8be3f2..70ca828985 100644
--- a/ts/packages/shell/test/tsconfig.json
+++ b/ts/packages/shell/test/tsconfig.json
@@ -7,5 +7,5 @@
     "types": ["node", "jest"]
   },
   "include": ["partialCompletion/**/*.ts"],
-  "references": [{ "path": "../src" }]
+  "references": [{ "path": "../src" }, { "path": "./renderer" }]
 }
diff --git a/ts/packages/utils/commonUtils/src/indexBrowser.ts b/ts/packages/utils/commonUtils/src/indexBrowser.ts
index 6ed8c3e1c1..c98007c1a0 100644
--- a/ts/packages/utils/commonUtils/src/indexBrowser.ts
+++ b/ts/packages/utils/commonUtils/src/indexBrowser.ts
@@ -11,6 +11,7 @@ export { createLimiter } from "./limiter.js";
 export { uint8ArrayToBase64, base64ToUint8Array } from "./base64Browser.js";
 
 export { createPromiseWithResolvers } from "./promiseWithResolvers.js";
+export { getLocalWhisperTranscription } from "./localWhisperClient.js";
 
 export {
     filterSecrets,
diff --git a/ts/packages/utils/commonUtils/src/indexNode.ts b/ts/packages/utils/commonUtils/src/indexNode.ts
index 686fc11bcb..12c0615f60 100644
--- a/ts/packages/utils/commonUtils/src/indexNode.ts
+++ b/ts/packages/utils/commonUtils/src/indexNode.ts
@@ -17,6 +17,7 @@ export {
 export { uint8ArrayToBase64, base64ToUint8Array } from "./base64Node.js";
 
 export { createPromiseWithResolvers } from "./promiseWithResolvers.js";
+export { getLocalWhisperTranscription } from "./localWhisperClient.js";
 
 export { resolveCliOnPath, claudeExecutableOption } from "./cliPath.js";
 
diff --git a/ts/packages/utils/commonUtils/src/localWhisperClient.ts b/ts/packages/utils/commonUtils/src/localWhisperClient.ts
new file mode 100644
index 0000000000..2d6ea2a12c
--- /dev/null
+++ b/ts/packages/utils/commonUtils/src/localWhisperClient.ts
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+export async function getLocalWhisperTranscription(
+    blob: Blob,
+    signal?: AbortSignal,
+): Promise<string> {
+    const formData = new FormData();
+    formData.append("file", blob);
+    const response = await fetch("http://localhost:8001/transcribe/", {
+        method: "POST",
+        body: formData,
+        ...(signal ? { signal } : {}),
+    });
+    const body: unknown = await response.json();
+    if (!response.ok) {
+        const message =
+            typeof body === "object" &&
+            body !== null &&
+            "error" in body &&
+            typeof body.error === "string"
+                ? body.error
+                : `Transcription failed with HTTP ${response.status}.`;
+        throw new Error(message);
+    }
+    if (
+        typeof body !== "object" ||
+        body === null ||
+        !("transcription" in body) ||
+        typeof body.transcription !== "string"
+    ) {
+        throw new Error(
+            "The transcription service returned an invalid response.",
+        );
+    }
+    return body.transcription;
+}
diff --git a/ts/packages/utils/commonUtils/test/localWhisperClient.spec.ts b/ts/packages/utils/commonUtils/test/localWhisperClient.spec.ts
new file mode 100644
index 0000000000..c2c594e7ea
--- /dev/null
+++ b/ts/packages/utils/commonUtils/test/localWhisperClient.spec.ts
@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { getLocalWhisperTranscription } from "../src/localWhisperClient.js";
+
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+});
+
+function respond(body: unknown, status = 200) {
+    globalThis.fetch = async () =>
+        new Response(JSON.stringify(body), { status });
+}
+
+it("posts the audio file and returns the transcription text", async () => {
+    const calls: Parameters<typeof fetch>[] = [];
+    globalThis.fetch = async (...args) => {
+        calls.push(args);
+        return new Response(JSON.stringify({ transcription: "hello" }));
+    };
+    expect(await getLocalWhisperTranscription(new Blob(["audio"]))).toBe(
+        "hello",
+    );
+    expect(calls).toHaveLength(1);
+    const [url, request] = calls[0] ?? [];
+    expect(url).toBe("http://localhost:8001/transcribe/");
+    expect(request?.method).toBe("POST");
+    expect(request?.body).toBeInstanceOf(FormData);
+});
+
+it("forwards an abort signal to the transcription request", async () => {
+    const controller = new AbortController();
+    let request: RequestInit | undefined;
+    globalThis.fetch = async (_input, init) => {
+        request = init;
+        return new Response(JSON.stringify({ transcription: "hello" }));
+    };
+    await getLocalWhisperTranscription(new Blob(["audio"]), controller.signal);
+    expect(request?.signal).toBe(controller.signal);
+});
+
+it.each([400, 408, 413, 422, 503])(
+    "reports the service message for HTTP %s",
+    async (status) => {
+        respond({ error: "Please retry." }, status);
+        await expect(
+            getLocalWhisperTranscription(new Blob(["audio"])),
+        ).rejects.toThrow("Please retry.");
+    },
+);
+
+it("reports a failed HTTP response without a service message", async () => {
+    respond({}, 503);
+    await expect(
+        getLocalWhisperTranscription(new Blob(["audio"])),
+    ).rejects.toThrow("Transcription failed with HTTP 503.");
+});
+
+it.each([{}, { transcription: null }, { transcription: 1 }])(
+    "rejects an invalid successful response: %j",
+    async (body) => {
+        respond(body);
+        await expect(
+            getLocalWhisperTranscription(new Blob(["audio"])),
+        ).rejects.toThrow(
+            "The transcription service returned an invalid response.",
+        );
+    },
+);
diff --git a/ts/pnpm-lock.yaml b/ts/pnpm-lock.yaml
index 09d1a312c6..4b2615a9c5 100644
--- a/ts/pnpm-lock.yaml
+++ b/ts/pnpm-lock.yaml
@@ -909,6 +909,9 @@ importers:
 
   examples/whisperClient:
     dependencies:
+      '@typeagent/common-utils':
+        specifier: workspace:*
+        version: link:../../packages/utils/commonUtils
       chalk:
         specifier: ^5.4.1
         version: 5.6.2