chore(release): bump version to 0.8.1

terranc · terranc · commit ac7121156227 · 2026-03-08T12:41:28.000+08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.1] - 2026-03-08
+
+### Fixed
+- Volcengine voice transcription now deletes the temporary TOS object after ASR completes, preventing staged voice files from accumulating over time
+- TOS cleanup failures are isolated to logs and no longer affect user-facing transcription replies
+
+### Changed
+- Extended TOS uploader API to return uploaded object metadata (`object_key` + signed URL) for explicit post-transcription cleanup
+- Added tests covering TOS object deletion on both success and failure paths
+
 ## [0.8.0] - 2026-03-08
 
 ### Added
diff --git a/core/bot.py b/core/bot.py
@@ -1905,10 +1905,15 @@ async def run_task():
                         outcome = "download_failed"
                         return
 
+                    uploaded_object_key: Optional[str] = None
                     try:
-                        audio_url = await asyncio.to_thread(
-                            tos_uploader.upload_file, source_path, user_id
+                        uploaded = await asyncio.to_thread(
+                            tos_uploader.upload_file_with_object_key,
+                            source_path,
+                            user_id,
                         )
+                        audio_url = uploaded.signed_url
+                        uploaded_object_key = uploaded.object_key
                     except TOSUploadError as exc:
                         logger.error(
                             "Failed to upload voice file to TOS for user %s: %s",
@@ -1954,6 +1959,20 @@ async def run_task():
                         )
                         outcome = "transcription_failed"
                         return
+                    finally:
+                        if uploaded_object_key:
+                            try:
+                                await asyncio.to_thread(
+                                    tos_uploader.delete_object, uploaded_object_key
+                                )
+                            except Exception as exc:
+                                logger.warning(
+                                    "Failed to delete temporary TOS voice object for user %s key=%s: %s",
+                                    user_id,
+                                    uploaded_object_key,
+                                    exc,
+                                    exc_info=True,
+                                )
                 else:
                     logger.error(
                         "Unsupported transcription provider '%s' for user %s",
diff --git a/tests/test_tos_uploader.py b/tests/test_tos_uploader.py
@@ -3,16 +3,29 @@
 from tempfile import TemporaryDirectory
 from types import SimpleNamespace
 
-from telegram_bot.utils.tos_uploader import TOSUploadError, VolcengineTOSUploader
+from telegram_bot.utils.tos_uploader import (
+    TOSUploadError,
+    TOSUploadedObject,
+    VolcengineTOSUploader,
+)
 
 
 class _FakeTOSClient:
-    def __init__(self, *, put_error=None, sign_error=None, signed_url=""):
+    def __init__(
+        self,
+        *,
+        put_error=None,
+        sign_error=None,
+        delete_error=None,
+        signed_url="",
+    ):
         self.put_error = put_error
         self.sign_error = sign_error
+        self.delete_error = delete_error
         self.signed_url = signed_url
         self.put_calls = []
         self.sign_calls = []
+        self.delete_calls = []
 
     def put_object_from_file(self, **kwargs):
         self.put_calls.append(kwargs)
@@ -26,6 +39,12 @@ def pre_signed_url(self, http_method, **kwargs):
             raise self.sign_error
         return SimpleNamespace(signed_url=self.signed_url)
 
+    def delete_object(self, **kwargs):
+        self.delete_calls.append(kwargs)
+        if self.delete_error is not None:
+            raise self.delete_error
+        return SimpleNamespace()
+
 
 class TOSUploaderTests(unittest.TestCase):
     def test_upload_file_returns_signed_url(self):
@@ -67,6 +86,67 @@ def test_upload_file_returns_signed_url(self):
             self.assertEqual(kwargs["key"], object_key)
             self.assertEqual(kwargs["expires"], 1200)
 
+    def test_upload_file_with_object_key_returns_metadata(self):
+        with TemporaryDirectory() as td:
+            path = Path(td) / "voice.ogg"
+            path.write_bytes(b"OggS")
+
+            client = _FakeTOSClient(
+                signed_url="https://tos.example.com/bucket/voice.ogg?X-Tos-Signature=abc"
+            )
+            uploader = VolcengineTOSUploader(
+                access_key="ak",
+                secret_access_key="sk",
+                endpoint="https://tos-cn-shanghai.volces.com",
+                region="cn-shanghai",
+                bucket_name="voice-stage",
+                signed_url_ttl_seconds=1200,
+                client=client,
+                http_method_get="GET",
+            )
+
+            uploaded = uploader.upload_file_with_object_key(path, user_id=42)
+
+            self.assertIsInstance(uploaded, TOSUploadedObject)
+            self.assertEqual(
+                uploaded.signed_url,
+                "https://tos.example.com/bucket/voice.ogg?X-Tos-Signature=abc",
+            )
+            self.assertTrue(uploaded.object_key.startswith("telegram-voice/42/"))
+            self.assertTrue(uploaded.object_key.endswith(".ogg"))
+
+    def test_delete_object_calls_tos_client(self):
+        client = _FakeTOSClient()
+        uploader = VolcengineTOSUploader(
+            access_key="ak",
+            secret_access_key="sk",
+            endpoint="https://tos-cn-shanghai.volces.com",
+            region="cn-shanghai",
+            bucket_name="voice-stage",
+            client=client,
+        )
+
+        uploader.delete_object("telegram-voice/42/object.ogg")
+
+        self.assertEqual(
+            client.delete_calls,
+            [{"bucket": "voice-stage", "key": "telegram-voice/42/object.ogg"}],
+        )
+
+    def test_delete_object_raises_when_client_delete_fails(self):
+        client = _FakeTOSClient(delete_error=RuntimeError("delete failed"))
+        uploader = VolcengineTOSUploader(
+            access_key="ak",
+            secret_access_key="sk",
+            endpoint="https://tos-cn-shanghai.volces.com",
+            region="cn-shanghai",
+            bucket_name="voice-stage",
+            client=client,
+        )
+
+        with self.assertRaises(TOSUploadError):
+            uploader.delete_object("telegram-voice/42/object.ogg")
+
     def test_upload_file_raises_when_upload_fails(self):
         with TemporaryDirectory() as td:
             path = Path(td) / "voice.ogg"
diff --git a/tests/test_voice_flow.py b/tests/test_voice_flow.py
@@ -134,7 +134,8 @@ def get_session_last_assistant_message(self, session_id):
 
 import telegram_bot.core.bot as bot_module
 from telegram_bot.core.bot import TelegramBot
-from telegram_bot.utils.transcription import EmptyTranscriptionError
+from telegram_bot.utils.tos_uploader import TOSUploadError
+from telegram_bot.utils.transcription import EmptyTranscriptionError, TranscriptionError
 
 _NOISY_LOGGERS = ["telegram_bot.core.bot"]
 _ORIGINAL_LEVELS = {}
@@ -342,10 +343,13 @@ async def run_now(user_id, run_task, on_overflow):
             side_effect=lambda path, cleanup: path
         )
         bot._process_user_message_text = AsyncMock()
+        uploaded = SimpleNamespace(
+            signed_url="https://tos.example.com/stage/voice.ogg?X-Tos-Signature=abc",
+            object_key="telegram-voice/11/object.ogg",
+        )
         uploader = SimpleNamespace(
-            upload_file=MagicMock(
-                return_value="https://tos.example.com/stage/voice.ogg?X-Tos-Signature=abc"
-            ),
+            upload_file_with_object_key=MagicMock(return_value=uploaded),
+            delete_object=MagicMock(return_value=None),
             redact_signed_url=lambda url: (
                 "https://tos.example.com/stage/voice.ogg?***REDACTED***"
             ),
@@ -367,11 +371,12 @@ async def run_now(user_id, run_task, on_overflow):
             bot_module.config.transcription_provider = old_provider
 
         bot._download_voice_file.assert_awaited_once()
-        self.assertEqual(uploader.upload_file.call_count, 1)
+        self.assertEqual(uploader.upload_file_with_object_key.call_count, 1)
         transcriber.transcribe_audio.assert_awaited_once_with(
             "https://tos.example.com/stage/voice.ogg?X-Tos-Signature=abc",
             duration_seconds=30,
         )
+        uploader.delete_object.assert_called_once_with("telegram-voice/11/object.ogg")
         bot._prepare_audio_for_whisper.assert_not_called()
         bot._process_user_message_text.assert_awaited_once()
         called = bot._process_user_message_text.await_args
@@ -381,6 +386,110 @@ async def run_now(user_id, run_task, on_overflow):
             "🎤 Voice: hello from volcengine",
         )
 
+    async def test_volcengine_delete_failure_does_not_break_successful_reply(self):
+        bot = TelegramBot()
+        bot._check_access = AsyncMock(return_value=True)
+
+        old_provider = bot_module.config.transcription_provider
+        config_module.config.transcription_provider = "volcengine"
+        bot_module.config.transcription_provider = "volcengine"
+
+        async def run_now(user_id, run_task, on_overflow):
+            del user_id, on_overflow
+            await run_task()
+            return True
+
+        bot._enqueue_user_task = run_now
+        bot._download_voice_file = AsyncMock(return_value=None)
+        bot._prepare_audio_for_whisper = AsyncMock(
+            side_effect=lambda path, cleanup: path
+        )
+        bot._process_user_message_text = AsyncMock()
+        uploader = SimpleNamespace(
+            upload_file_with_object_key=MagicMock(
+                return_value=SimpleNamespace(
+                    signed_url="https://tos.example.com/stage/voice.ogg?X-Tos-Signature=abc",
+                    object_key="telegram-voice/11/object.ogg",
+                )
+            ),
+            delete_object=MagicMock(side_effect=TOSUploadError("delete failed")),
+            redact_signed_url=lambda url: (
+                "https://tos.example.com/stage/voice.ogg?***REDACTED***"
+            ),
+        )
+        bot._get_volcengine_tos_uploader = lambda: uploader
+        transcriber = SimpleNamespace(
+            transcribe_audio=AsyncMock(return_value="hello from volcengine")
+        )
+        bot._get_volcengine_transcriber = lambda: transcriber
+        voice = SimpleNamespace(file_id="v1", duration=30, mime_type="audio/ogg")
+        update = _build_update(11, voice)
+
+        try:
+            with TemporaryDirectory() as td:
+                bot._audio_dir = Path(td)
+                await bot._handle_voice_message(update, None)
+        finally:
+            config_module.config.transcription_provider = old_provider
+            bot_module.config.transcription_provider = old_provider
+
+        transcriber.transcribe_audio.assert_awaited_once()
+        uploader.delete_object.assert_called_once_with("telegram-voice/11/object.ogg")
+        bot._process_user_message_text.assert_awaited_once()
+
+    async def test_volcengine_transcription_failure_still_deletes_tos_object(self):
+        bot = TelegramBot()
+        bot._check_access = AsyncMock(return_value=True)
+
+        old_provider = bot_module.config.transcription_provider
+        config_module.config.transcription_provider = "volcengine"
+        bot_module.config.transcription_provider = "volcengine"
+
+        async def run_now(user_id, run_task, on_overflow):
+            del user_id, on_overflow
+            await run_task()
+            return True
+
+        bot._enqueue_user_task = run_now
+        bot._download_voice_file = AsyncMock(return_value=None)
+        uploader = SimpleNamespace(
+            upload_file_with_object_key=MagicMock(
+                return_value=SimpleNamespace(
+                    signed_url="https://tos.example.com/stage/voice.ogg?X-Tos-Signature=abc",
+                    object_key="telegram-voice/11/object.ogg",
+                )
+            ),
+            delete_object=MagicMock(return_value=None),
+            redact_signed_url=lambda url: (
+                "https://tos.example.com/stage/voice.ogg?***REDACTED***"
+            ),
+        )
+        bot._get_volcengine_tos_uploader = lambda: uploader
+        transcriber = SimpleNamespace(
+            transcribe_audio=AsyncMock(side_effect=TranscriptionError("asr failed"))
+        )
+        bot._get_volcengine_transcriber = lambda: transcriber
+        bot._process_user_message_text = AsyncMock()
+        voice = SimpleNamespace(file_id="v1", duration=30, mime_type="audio/ogg")
+        update = _build_update(11, voice)
+
+        try:
+            with TemporaryDirectory() as td:
+                bot._audio_dir = Path(td)
+                await bot._handle_voice_message(update, None)
+        finally:
+            config_module.config.transcription_provider = old_provider
+            bot_module.config.transcription_provider = old_provider
+
+        uploader.delete_object.assert_called_once_with("telegram-voice/11/object.ogg")
+        bot._process_user_message_text.assert_not_awaited()
+        self.assertTrue(
+            any(
+                "Failed to transcribe your voice message" in msg
+                for msg in update.message.replies
+            )
+        )
+
     async def test_reports_missing_volcengine_configuration(self):
         bot = TelegramBot()
         bot._check_access = AsyncMock(return_value=True)
diff --git a/utils/tos_uploader.py b/utils/tos_uploader.py
@@ -3,6 +3,7 @@
 import secrets
 import time
 import uuid
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Optional
 from urllib.parse import urlparse, urlunparse
@@ -14,6 +15,12 @@ class TOSUploadError(RuntimeError):
     """Raised when uploading or signing a TOS object fails."""
 
 
+@dataclass(frozen=True)
+class TOSUploadedObject:
+    object_key: str
+    signed_url: str
+
+
 class VolcengineTOSUploader:
     """Upload local voice files to Volcengine TOS and return signed URLs."""
 
@@ -82,6 +89,12 @@ def __init__(
             self._http_method_get = self._http_method_get or "GET"
 
     def upload_file(self, local_path: Path, user_id: int) -> str:
+        uploaded = self.upload_file_with_object_key(local_path, user_id)
+        return uploaded.signed_url
+
+    def upload_file_with_object_key(
+        self, local_path: Path, user_id: int
+    ) -> TOSUploadedObject:
         source = Path(local_path)
         suffix = source.suffix or ".ogg"
         object_key = self._build_object_key(source, user_id, suffix)
@@ -116,7 +129,26 @@ def upload_file(self, local_path: Path, user_id: int) -> str:
             object_key,
             self.redact_signed_url(signed_url),
         )
-        return signed_url
+        return TOSUploadedObject(object_key=object_key, signed_url=signed_url)
+
+    def delete_object(self, object_key: str) -> None:
+        key = str(object_key or "").strip()
+        if not key:
+            raise ValueError("object_key is required for TOS delete.")
+
+        try:
+            self._client.delete_object(
+                bucket=self.bucket_name,
+                key=key,
+            )
+        except Exception as exc:
+            raise TOSUploadError("Failed to delete Volcengine TOS object.") from exc
+
+        logger.debug(
+            "Deleted temporary voice file from Volcengine TOS bucket=%s key=%s",
+            self.bucket_name,
+            key,
+        )
 
     @staticmethod
     def _build_object_key(source: Path, user_id: int, suffix: str) -> str:
