fix: resolve sync regressions and CI failures

Author: LIghtJUNction

astrbot/core/computer/booters/cua.py

@@ -27,6 +27,7 @@
 )
 
 _POSIX_OS_TYPES = {"linux", "darwin", "macos"}
+_CUA_SANDBOX_HEALTH_PROBE = "_astrbot_cua_ok_"
 
 _CUA_BACKGROUND_LAUNCHER = """
 import subprocess, sys, time
@@ -67,10 +68,18 @@ async def _write_base64_via_shell(
     encoded = base64.b64encode(data).decode("ascii")
     decoder = (
         "import base64,pathlib,sys; "
-        "pathlib.Path(sys.argv[1]).write_bytes(base64.b64decode(sys.stdin.read()))"
+        "path=pathlib.Path(sys.argv[1]); "
+        "path.parent.mkdir(parents=True, exist_ok=True); "
+        "path.write_bytes(base64.b64decode(sys.stdin.read()))"
+    )
+    chunk_size = 60_000
+    encoded_lines = "\n".join(
+        encoded[index : index + chunk_size]
+        for index in range(0, len(encoded), chunk_size)
     )
     return await shell.exec(
-        f"python3 -c {shlex.quote(decoder)} {shlex.quote(path)} <<'EOF'\n{encoded}\nEOF",
+        f"python3 -c {shlex.quote(decoder)} {shlex.quote(path)} <<'EOF'\n"
+        f"{encoded_lines}\nEOF",
     )
 
 
@@ -976,4 +985,18 @@ async def download_file(self, remote_path: str, local_path: str) -> None:
         )
 
     async def available(self) -> bool:
-        return self._runtime is not None
+        if self._runtime is None:
+            return False
+        try:
+            result = await self._runtime.shell.exec(
+                f"echo {_CUA_SANDBOX_HEALTH_PROBE}",
+                timeout=10,
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.debug("[Computer] CUA sandbox health check failed: %s", exc)
+            return False
+        if result.get("exit_code") != 0:
+            return False
+        return _CUA_SANDBOX_HEALTH_PROBE in str(result.get("stdout", ""))

astrbot/core/platform/sources/discord/discord_platform_adapter.py

@@ -26,7 +26,6 @@
     StarHandlerMetadata,
     star_handlers_registry,
 )
-from astrbot.core.utils.media_utils import MediaResolver
 
 from .client import DiscordBotClient
 from .discord_platform_event import DiscordPlatformEvent
@@ -277,20 +276,7 @@ def _convert_message_to_abm(self, data: dict) -> AstrBotMessage:
     async def convert_message(self, data: dict) -> AstrBotMessage:
         """将平台消息转换成 AstrBotMessage"""
         # 由于 on_interaction 已被禁用,我们只处理普通消息
-        abm = self._convert_message_to_abm(data)
-        for component in abm.message:
-            if isinstance(component, Record):
-                audio_ref = component.url or component.file
-                if audio_ref:
-                    path_wav = await MediaResolver(
-                        audio_ref,
-                        media_type="audio",
-                        default_suffix=".wav",
-                    ).to_path(target_format="wav")
-                    component.file = path_wav
-                    component.url = path_wav
-                    component.path = path_wav
-        return abm
+        return self._convert_message_to_abm(data)
 
     async def handle_msg(self, message: AstrBotMessage, followup_webhook=None) -> None:
         """处理消息"""

astrbot/core/platform/sources/lark/lark_adapter.py

@@ -25,7 +25,6 @@
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.platform.register import register_platform_adapter
 from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
-from astrbot.core.utils.media_utils import MediaResolver
 from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from .bot_info import request_lark_bot_info
@@ -288,12 +287,7 @@ async def _parse_message_components(
                 default_suffix=".opus",
             )
             if file_path:
-                path_wav = await MediaResolver(
-                    file_path,
-                    media_type="audio",
-                    default_suffix=".wav",
-                ).to_path(target_format="wav")
-                components.append(Comp.Record(file=path_wav, url=path_wav))
+                components.append(Comp.Record(file=file_path, url=file_path))
             return components
         if message_type == "media":
             file_key = str(content.get("file_key", "")).strip()

astrbot/core/platform/sources/line/line_adapter.py

@@ -19,7 +19,6 @@
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.platform.register import register_platform_adapter
 from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
-from astrbot.core.utils.media_utils import MediaResolver
 from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from .line_api import LineAPIClient
@@ -308,24 +307,14 @@ async def _build_audio_component(
     ) -> Record | None:
         external_url = self._get_external_content_url(message)
         if external_url:
-            path_wav = await MediaResolver(
-                external_url,
-                media_type="audio",
-                default_suffix=".wav",
-            ).to_path(target_format="wav")
-            return Record(file=path_wav, url=path_wav)
+            return Record(file=external_url, url=external_url)
         content = await self.line_api.get_message_content(message_id)
         if not content:
             return None
         content_bytes, content_type, _ = content
         suffix = self._guess_suffix(content_type, ".m4a")
         file_path = self._store_temp_content("audio", message_id, content_bytes, suffix)
-        path_wav = await MediaResolver(
-            file_path,
-            media_type="audio",
-            default_suffix=".wav",
-        ).to_path(target_format="wav")
-        return Record(file=path_wav, url=path_wav)
+        return Record(file=file_path, url=file_path)
 
     async def _build_file_component(
         self,

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -37,7 +37,6 @@
 from astrbot.core.message.components import BaseMessageComponent
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.platform.register import register_platform_adapter
-from astrbot.core.utils.media_utils import MediaResolver
 
 from .qqofficial_message_event import QQOfficialMessageEvent
 
@@ -505,14 +504,7 @@ def _normalize_attachment_url(url: str | None) -> str:
 
     @staticmethod
     async def _prepare_audio_attachment(url: str, filename: str) -> Record:
-        ext = Path(filename).suffix.lower()
-        source_ext = ext or ".audio"
-        path_wav = await MediaResolver(
-            url,
-            media_type="audio",
-            default_suffix=source_ext,
-        ).to_path(target_format="wav")
-        return Record(file=path_wav, url=path_wav)
+        return Record(file=url, url=url)
 
     @staticmethod
     async def _append_attachments(

astrbot/core/platform/sources/telegram/tg_adapter.py

@@ -231,6 +231,7 @@ async def run(self) -> None:
                         logger.warning(
                             f"Telegram polling loop exited unexpectedly, retrying in {self._polling_restart_delay}s.",
                         )
+                        await asyncio.sleep(self._polling_restart_delay)
                     continue
 
                 if not self._terminating:

astrbot/core/provider/sources/openai_source.py

@@ -369,6 +369,7 @@ async def _resolve_audio_part(self, audio_ref: str) -> dict | None:
                 audio_ref,
                 media_type="audio",
                 strict=True,
+                preserve_mp3=True,
             )
         except Exception as exc:
             logger.warning("音频预处理失败，将忽略。错误: %s", exc)
@@ -699,6 +700,7 @@ async def _query(
                 stream=False,
                 extra_body=extra_body,
             ),
+            retry_rate_limits=False,
             max_attempts=request_max_retries,
         )
 
@@ -758,6 +760,7 @@ async def _query_stream(
                 extra_body=extra_body,
                 stream_options={"include_usage": True},
             ),
+            retry_rate_limits=False,
             max_attempts=request_max_retries,
         )
 

astrbot/core/provider/sources/whisper_api_source.py

@@ -1,24 +1,10 @@
-import os
-import uuid
-
-import anyio
 from openai import NOT_GIVEN, AsyncOpenAI
 
-from astrbot.core import logger
-from astrbot.core.provider.entities import ProviderType
-from astrbot.core.provider.provider import STTProvider
-from astrbot.core.provider.register import register_provider_adapter
-from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
-from astrbot.core.utils.io import download_file
-from astrbot.core.utils.media_utils import convert_audio_to_wav
-from astrbot.core.utils.tencent_record_helper import (
-    convert_to_pcm_wav,
-    tencent_silk_to_wav,
-)
-
+from astrbot.core.utils.media_utils import MediaResolver
 
-def _open_file_rb(path: str):
-    return open(path, "rb")
+from ..entities import ProviderType
+from ..provider import STTProvider
+from ..register import register_provider_adapter
 
 
 @register_provider_adapter(
@@ -43,98 +29,18 @@ def __init__(
 
         self.set_model(provider_config["model"])
 
-    async def _get_audio_format(self, file_path) -> str | None:
-        # 定义要检测的头部字节
-        silk_header = b"SILK"
-        amr_header = b"#!AMR"
-
-        try:
-            async with await anyio.open_file(file_path, "rb") as f:
-                file_header = await f.read(8)
-        except FileNotFoundError:
-            return None
-
-        if silk_header in file_header:
-            return "silk"
-
-        if amr_header in file_header:
-            return "amr"
-        return None
-
     async def get_text(self, audio_url: str) -> str:
         """Only supports mp3, mp4, mpeg, m4a, wav, webm"""
-        is_tencent = False
-        output_path = None
-
-        if audio_url.startswith("http"):
-            if "multimedia.nt.qq.com.cn" in audio_url:
-                is_tencent = True
-
-            temp_dir = get_astrbot_temp_path()
-            path = os.path.join(
-                temp_dir,
-                f"whisper_api_{uuid.uuid4().hex[:8]}.input",
-            )
-            await download_file(audio_url, path)
-            audio_url = path
-
-        if not await anyio.Path(audio_url).exists():
-            raise FileNotFoundError(f"文件不存在: {audio_url}")
-
-        lower_audio_url = audio_url.lower()
-
-        if lower_audio_url.endswith(".opus"):
-            temp_dir = get_astrbot_temp_path()
-            output_path = os.path.join(
-                temp_dir,
-                f"whisper_api_{uuid.uuid4().hex[:8]}.wav",
-            )
-            logger.info("Converting opus file to wav using convert_audio_to_wav...")
-            await convert_audio_to_wav(audio_url, output_path)
-            audio_url = output_path
-        elif (
-            lower_audio_url.endswith(".amr")
-            or lower_audio_url.endswith(".silk")
-            or is_tencent
-        ):
-            file_format = await self._get_audio_format(audio_url)
-
-            # 判断是否需要转换
-            if file_format in ["silk", "amr"]:
-                temp_dir = get_astrbot_temp_path()
-                output_path = os.path.join(
-                    temp_dir,
-                    f"whisper_api_{uuid.uuid4().hex[:8]}.wav",
+        async with MediaResolver(
+            audio_url,
+            media_type="audio",
+            default_suffix=".wav",
+        ).as_path(target_format="wav") as audio:
+            with audio.open("rb") as audio_file:
+                result = await self.client.audio.transcriptions.create(
+                    model=self.model_name,
+                    file=("audio.wav", audio_file),
                 )
-
-                if file_format == "silk":
-                    logger.info(
-                        "Converting silk file to wav using tencent_silk_to_wav...",
-                    )
-                    await tencent_silk_to_wav(audio_url, output_path)
-                elif file_format == "amr":
-                    logger.info(
-                        "Converting amr file to wav using convert_to_pcm_wav...",
-                    )
-                    await convert_to_pcm_wav(audio_url, output_path)
-
-                audio_url = output_path
-
-        file_obj = await anyio.to_thread.run_sync(_open_file_rb, audio_url)  # type: ignore[call-arg]
-        try:
-            result = await self.client.audio.transcriptions.create(
-                model=self.model_name,
-                file=("audio.wav", file_obj),
-            )
-        finally:
-            file_obj.close()
-
-        # remove temp file
-        if output_path and await anyio.Path(output_path).exists():
-            try:
-                await anyio.Path(audio_url).unlink()
-            except Exception as e:
-                logger.error(f"Failed to remove temp file {audio_url}: {e}")
         return result.text
 
     async def terminate(self):

astrbot/core/utils/astrbot_path.py

@@ -14,6 +14,7 @@
 """
 
 import os
+import tempfile
 from importlib import resources
 from pathlib import Path
 
@@ -257,8 +258,8 @@ def get_astrbot_backups_path() -> str:
 
 
 def get_astrbot_system_tmp_path() -> str:
-    """获取Astrbot系统临时目录路径 (/tmp/.astrbot)"""
-    return "/tmp/.astrbot"
+    """获取当前平台的 AstrBot 系统临时目录路径。"""
+    return os.path.realpath(os.path.join(tempfile.gettempdir(), ".astrbot"))
 
 
 def get_astrbot_workspaces_path() -> str:

astrbot/core/utils/media_utils.py

@@ -930,6 +930,7 @@ async def resolve_media_ref_to_base64_data(
     *,
     media_type: str,
     strict: bool = False,
+    preserve_mp3: bool = False,
 ) -> ResolvedMediaData | None:
     """Resolve a media reference to base64 data through one shared entrypoint.
 
@@ -940,7 +941,10 @@ async def resolve_media_ref_to_base64_data(
     if media_type == "image":
         return await resolve_image_ref_to_base64_data(media_ref, strict=strict)
     if media_type == "audio":
-        return await resolve_audio_ref_to_base64_data(media_ref)
+        return await resolve_audio_ref_to_base64_data(
+            media_ref,
+            preserve_mp3=preserve_mp3,
+        )
 
     return await MediaResolver(
         media_ref,