aichat-sdk 0.1.0__py3-none-any.whl

aichat_sdk/__init__.py

@@ -0,0 +1,423 @@
+import asyncio
+import json
+import logging
+from typing import Any
+
+from aichat_sdk.asr.asr_client import AsrWebSocketClient
+from aichat_sdk.config import ASR_SERVER_WS_URL
+from aichat_sdk.llm import LlmAgent
+from aichat_sdk.llm.mcp import get_default_chat_tools
+from aichat_sdk.llm.type_enum import AgentInfo, DeviceInfo
+from aichat_sdk.utils.opus_codec import (
+    OpusStreamDecoder,
+    OpusStreamEncoder,
+    PcmStreamResampler,
+)
+
+__version__ = "0.1.0"
+
+
+logger = logging.getLogger(__name__)
+
+IDLE_TIMEOUT_SECONDS = 60
+IDLE_FAREWELL_PROMPT = (
+    "用户已长时间没有说话，本次会话即将自动结束。"
+    "请直接输出一两句简短自然的道别话，可以结合刚才聊到的内容。"
+    "只输出纯文本，不要调用任何工具，也不要向用户提问或期待回复。"
+)
+
+
+def get_tts_client(tts_engine: str = "bytedance"):
+    engine = tts_engine.lower()
+    if engine in {"edge", "edge-tts"}:
+        from aichat_sdk.tts.edge.bidirection import EdgeTTSClient
+
+        return EdgeTTSClient()
+    if engine in {"bytedance", "v2", "bytedancev2"}:
+        from aichat_sdk.tts.bytedancev2.bidirection import BytedanceTTSClient
+
+        return BytedanceTTSClient(voice_type="zh_female_wanwanxiaohe_moon_bigtts")
+    if engine in {"v3", "bytedancev3"}:
+        from aichat_sdk.tts.bytedancev3.bidirection import BytedanceTTSClient
+
+        return BytedanceTTSClient(voice_type="zh_female_vv_uranus_bigtts")
+    raise ValueError("未知 tts_engine，支持: bytedance, v2, v3, edge")
+
+
+class ChatBot:
+    def __init__(
+        self,
+        tts_engine: str = "bytedance",
+        input_sample_rate: int = 24000,  # Opus 编码采样率(限 8k/12k/16k/24k/48k)，TTS 源 PCM 采样率不同时会自动重采样;
+        output_sample_rate: int = 24000,  # 宿主解码后拿到的 PCM 采样率(任意),解码器用 create_opus_decoder() 创建。
+        asr_server_url: str = ASR_SERVER_WS_URL,  # ASR 服务地址
+        send_idle_farewell: bool = True,  # 空闲超时后是否先发送告别语,为 False 时直接关闭会话。
+        user_info: DeviceInfo = DeviceInfo(timezone=8, city="北京"),  # 用户信息
+        agent_info: AgentInfo = AgentInfo(),  # 角色信息
+    ) -> None:
+        """input_sample_rate:Opus 编码采样率(限 8k/12k/16k/24k/48k)，
+        TTS 源 PCM 采样率不同时会自动重采样;
+        output_sample_rate:宿主解码后拿到的 PCM 采样率(任意),解码器用 create_opus_decoder() 创建。
+        send_idle_farewell:空闲超时后是否先发送告别语,为 False 时直接关闭会话。
+        """
+        self.tts = get_tts_client(tts_engine)
+        self.asr = AsrWebSocketClient(asr_server_url)
+
+        self.output_sample_rate = output_sample_rate
+        self._send_idle_farewell = send_idle_farewell
+        self.llm = LlmAgent(user_info=user_info, agent_info=agent_info)
+        self._queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+        self._input_sample_rate = input_sample_rate
+        self._opus_encoder = OpusStreamEncoder(input_sample_rate)
+        self._pcm_resampler: PcmStreamResampler | None = None
+        self._audio_text = ""
+        self._audio_terminal_sent = True
+        self._tts_session_started = False
+        self._chat_task: asyncio.Task | None = None
+        self._session_lock = asyncio.Lock()
+        self._asr_dispatch_tasks: set[asyncio.Task] = set()
+        self._pending_mcp_call: tuple[str, dict[str, Any]] | None = None
+        # 宿主从队列取走 audio_finish 时置位，等"真正播完"用
+        self._audio_finish_consumed = asyncio.Event()
+
+        self._is_session_closed = False
+        self._idle_task: asyncio.Task | None = None
+
+    def create_opus_decoder(self) -> OpusStreamDecoder:
+        """给宿主建配套解码器,输出 output_sample_rate 的 PCM,按同样的采样率播放。"""
+        return OpusStreamDecoder(self.output_sample_rate)
+
+    def audio_callback(self, indata, frames, time, status) -> None:
+        """把宿主采集的 16 kHz 单声道 Float32 PCM 发往 ASR 服务。"""
+        self.asr.audio_callback(indata, frames, time, status)
+
+    def _start_idle_timer(self):
+        self._cancel_idle_timer()
+        if not self._is_session_closed:
+            self._idle_task = asyncio.create_task(self._idle_farewell())
+
+    def _cancel_idle_timer(self):
+        if self._idle_task and not self._idle_task.done():
+            self._idle_task.cancel()
+        self._idle_task = None
+
+    async def _idle_farewell(self):
+        """超过 IDLE_TIMEOUT_SECONDS 用户无回复,按配置告别或直接结束会话。"""
+        await asyncio.sleep(IDLE_TIMEOUT_SECONDS)
+        # 先清引用再 send_text,否则 send_text 里的 abort 会把当前任务自己 cancel 掉
+        self._idle_task = None
+        self._is_session_closed = True
+
+        if self._send_idle_farewell:
+            logger.info(f"[idle] 用户超过 {IDLE_TIMEOUT_SECONDS}s 未回复,推送告别")
+            await self.send_text("", response_instructions=IDLE_FAREWELL_PROMPT, role="user")
+            # await self.send_text(IDLE_FAREWELL_PROMPT, role="system")
+
+        else:
+            logger.info(f"[idle] 用户超过 {IDLE_TIMEOUT_SECONDS}s 未回复,直接关闭")
+            await self._queue.put({"type": "close"})
+
+    async def receive_item(self):
+        item = await self._queue.get()
+        if item.get("type") == "lyric":
+            logger.info(f"[music] lyric: {item['data']}")
+        # 空闲计时以宿主消费(≈播放)节奏为准:取到 audio_finish 即真正播完、开始计时;
+        # 音频是瞬间推满队列的(整首歌几秒推完),按推送侧计时会在播放途中误触发。
+        elif item.get("type") == "audio_finish":
+            self._start_idle_timer()
+            self._audio_finish_consumed.set()
+        elif item.get("type") == "audio":
+            self._cancel_idle_timer()
+        return item
+
+    async def reg_llm(self):
+
+        @self.llm.on("text")
+        async def handle_chat_text(text: str):
+            # 会话开着但 10s 没收到文本，服务端就把它作废:之后送的字不再出声,
+            # FinishSession 也可能不回(实测 9s 正常、10s 起必挂)。工具调用和
+            # LLM 首字慢都能轻松撑过 10s，所以等真的有字了再开会话。
+            if not self._tts_session_started:
+                self._tts_session_started = True
+                await self.tts.start_session()
+            await self.tts.send_char(text)
+
+        @self.llm.on("tool")
+        async def handle_chat_tool(payload: dict):
+            arguments_str = payload["arguments"]
+            if len(arguments_str) > 50:
+                arguments_str = arguments_str[:50] + "..."
+            logger.info(f"[tool] tool_call: {payload['name']} ({arguments_str})")
+            await self._queue.put({"type": "tool", "data": payload})
+
+        @self.llm.on("before_tool_exec")
+        async def handle_chat_before_tool_exec(text: str):
+            await self._wait_audio_played(text)
+
+        @self.llm.on("tool_results")
+        async def handle_chat_tool_results(payload: list[dict]):
+            payload_str = json.dumps(payload, ensure_ascii=False)
+            if len(payload_str) > 100:
+                payload_str = payload_str[:100] + "..."
+            logger.info(f"[tool] tool_results: {payload_str}")
+            await self._queue.put({"type": "tool_results", "data": payload})
+
+            if any(msg.get("name") == "end_session" for msg in payload):
+                self._is_session_closed = True
+
+            for msg in payload:
+                if msg["name"] == "play_music":
+                    try:
+                        result = json.loads(msg["content"])
+                        mcp_name = result.get("mcp")
+                        song = result.get("song")
+                        if isinstance(mcp_name, str) and isinstance(song, str):
+                            self._pending_mcp_call = (mcp_name, {"song": song})
+                    except (json.JSONDecodeError, KeyError, TypeError):
+                        pass  # 结果里没有 path 说明选歌失败，无需播放
+
+        @self.llm.on("finish")
+        async def handle_chat_finish(text: str):
+            self._audio_text = text
+            await self.tts.finish_session()
+            # 正常实现会在 finish_session 内触发 audio_finish；这里作为协议
+            # 兜底，防止第三方 TTS 返回却忘记发终结事件。
+            await self._finish_audio_and_followups()
+
+    async def reg_tts(self):
+
+        @self.tts.on("audio")
+        async def handle_audio(pcm_data: bytes):
+            if self._pcm_resampler is not None:
+                pcm_data = self._pcm_resampler.resample(pcm_data)
+            for packet in self._opus_encoder.encode(pcm_data):
+                await self._queue.put({"type": "audio", "data": packet})
+
+        @self.tts.on("audio_finish")
+        async def handle_audio_finish():
+            await self._finish_audio_and_followups()
+
+        @self.tts.on("sentence_start")
+        async def handle_sentence_start(text: str):
+            logger.info(f"[tts] {text}")
+            await self._queue.put({"type": "sentence_start", "data": text})
+
+        @self.tts.on("sentence_end")
+        async def handle_sentence_end(text: str):
+            await self._queue.put({"type": "sentence_end", "data": text})
+
+    async def reg_asr(self):
+        @self.asr.on("stt")
+        async def handle_stt(payload: dict):
+            logger.info(f"[asr] {payload['content']}")
+            self.tts.set_last_context_text(payload["content"])
+            task = asyncio.create_task(self.send_text(payload["content"], audio_url=payload.get("audio_url")))
+            self._asr_dispatch_tasks.add(task)
+            task.add_done_callback(self._finish_asr_dispatch)
+
+        @self.asr.on("error")
+        async def handle_asr_error(payload: dict):
+            logger.error("[asr] server error: %s", payload)
+
+    def _finish_asr_dispatch(self, task: asyncio.Task) -> None:
+        self._asr_dispatch_tasks.discard(task)
+        if task.cancelled():
+            return
+        error = task.exception()
+        if error is not None:
+            logger.error(
+                "ASR result dispatch failed",
+                exc_info=(type(error), error, error.__traceback__),
+            )
+
+    async def initialize(self):
+        await self.reg_llm()
+        await self.reg_tts()
+        await self.reg_asr()
+        try:
+            await self.asr.connect()
+        except Exception as e:
+            logger.error(f"ASR connect failed: {e}")
+            await self.asr.close()
+            exit(1)
+        try:
+            await self.tts.connect()
+        except Exception as e:
+            logger.error(f"TTS connect failed: {e}")
+            await self.tts.close()
+            exit(1)
+        # 工具列表是懒构建的，不预热的话第一次拉起外部 MCP server（stdio 子进程）
+        # 的耗时会算进第一轮回复；构建是阻塞调用，放线程里跑不挡事件循环。
+        await asyncio.to_thread(get_default_chat_tools)
+        source_sample_rate = getattr(
+            self.tts,
+            "sample_rate",
+            self._input_sample_rate,
+        )
+        if source_sample_rate != self._input_sample_rate:
+            self._pcm_resampler = PcmStreamResampler(
+                source_sample_rate,
+                self._input_sample_rate,
+            )
+        self._start_idle_timer()
+
+    async def close(self):
+        self._cancel_idle_timer()
+        for task in self._asr_dispatch_tasks:
+            task.cancel()
+        if self._asr_dispatch_tasks:
+            await asyncio.gather(
+                *self._asr_dispatch_tasks,
+                return_exceptions=True,
+            )
+        self._asr_dispatch_tasks.clear()
+        await self.abort()
+        await self.asr.close()
+        close = getattr(self.tts, "close", None) or getattr(
+            self.tts,
+            "disconnect",
+            None,
+        )
+        if close is not None:
+            await close()
+
+    async def _run_session_task(self, coroutine_factory) -> None:
+        async with self._session_lock:
+            await self._abort_locked()
+            task = asyncio.create_task(coroutine_factory())
+            self._chat_task = task
+        try:
+            await task
+        except asyncio.CancelledError:
+            # 被下一轮会话替换时，只有子任务被 cancel，当前包装任务本身没有
+            # cancellation request；调用方主动 cancel 时则清理会话并继续传播。
+            if asyncio.current_task().cancelling():
+                async with self._session_lock:
+                    if self._chat_task is task:
+                        await self._abort_locked(notify_host=True)
+                raise
+        finally:
+            async with self._session_lock:
+                if self._chat_task is task:
+                    self._chat_task = None
+
+    async def send_text(self, user_text: str, role: str = "user", response_instructions: str = None, audio_url: str | None = None):
+        """audio_url:这句话对应的用户录音地址(ASR 服务给的),只挂在 messages 上供宿主回放,不发给 LLM。"""
+        await self._run_session_task(lambda: self._run_chat(user_text, role, response_instructions, audio_url))
+
+    async def _run_chat(self, user_text: str, role, response_instructions, audio_url: str | None = None):
+        self._prepare_audio_session()
+        try:
+            await self._queue.put({"type": "stt", "data": user_text})
+            await self.llm.chat(user_text, role, response_instructions, audio_url=audio_url)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("chat pipeline failed")
+            await self._fail_audio_session()
+            raise
+
+    async def send_tts_text(self, text: str):
+        await self._run_session_task(lambda: self._run_tts_text(text))
+
+    async def _run_tts_text(self, text: str) -> None:
+        self._prepare_audio_session()
+        try:
+            await self.tts.start_session()
+            await self.tts.send_char(text)
+            self._audio_text = text
+            await self.tts.finish_session()
+            await self._finish_audio_and_followups()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("direct TTS pipeline failed")
+            await self._fail_audio_session()
+            raise
+
+    async def _wait_audio_played(self, text: str) -> None:
+        """工具执行前等本轮已出声的文本真正播完。
+
+        先收掉 TTS 会话、推 audio_finish，再等宿主把它取走（音频是瞬间推满队列的，
+        只有宿主取到 audio_finish 才算播完）。之后按新一段音频处理:工具返回后的
+        回复重新开会话、结束时再推一条 audio_finish。一个字都没吐过就不用等，
+        也不能去收一个没开过的会话。
+        """
+        if not self._tts_session_started:
+            return
+        self._audio_text = text
+        self._audio_finish_consumed.clear()
+        await self.tts.finish_session()
+        await self._finish_audio_and_followups()
+        await self._audio_finish_consumed.wait()
+        # 取走 audio_finish 会起空闲计时，但工具还在跑，不算用户没回复
+        self._cancel_idle_timer()
+        self._prepare_audio_session()
+
+    def _prepare_audio_session(self) -> None:
+        self._audio_text = ""
+        self._audio_terminal_sent = False
+        self._tts_session_started = False
+
+    async def _enqueue_audio_finish(self) -> bool:
+        if self._audio_terminal_sent:
+            return False
+        self._audio_terminal_sent = True
+        if self._pcm_resampler is not None:
+            pcm = self._pcm_resampler.flush()
+            for packet in self._opus_encoder.encode(pcm):
+                await self._queue.put({"type": "audio", "data": packet})
+        for packet in self._opus_encoder.flush():
+            await self._queue.put({"type": "audio", "data": packet})
+        await self._queue.put({"type": "audio_finish", "data": self._audio_text})
+        return True
+
+    async def _finish_audio_and_followups(self) -> None:
+        if not await self._enqueue_audio_finish():
+            return
+        if self._is_session_closed:
+            await self._queue.put({"type": "close"})
+        elif self._pending_mcp_call:
+            # 等本轮回复的语音播完再开始放歌，避免歌声盖住回复
+            name, args = self._pending_mcp_call
+            self._pending_mcp_call = None
+            async for data in self.llm.stream_mcp_tool(name, args):
+                await self._queue.put(data)
+
+    async def _fail_audio_session(self) -> None:
+        try:
+            await self.tts.abort()
+        except Exception:
+            logger.exception("failed to abort TTS after pipeline error")
+        await self._enqueue_audio_finish()
+
+    async def abort(self):
+        async with self._session_lock:
+            await self._abort_locked(notify_host=True)
+
+    async def _abort_locked(self, *, notify_host: bool = False) -> None:
+        self._cancel_idle_timer()
+        session_was_active = not self._audio_terminal_sent
+        task = self._chat_task
+        if task and task is not asyncio.current_task() and not task.done():
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+
+        if self._chat_task is task:
+            self._chat_task = None
+        self._pending_mcp_call = None
+        try:
+            await self.tts.abort()
+        except Exception:
+            logger.exception("failed to abort TTS session")
+        if self._pcm_resampler is not None:
+            self._pcm_resampler.reset()
+        self._opus_encoder.reset()
+        removed_audio_finish = False
+        while not self._queue.empty():
+            item = self._queue.get_nowait()
+            removed_audio_finish |= item.get("type") == "audio_finish"
+        self._audio_text = ""
+        self._audio_terminal_sent = True
+        if notify_host and (session_was_active or removed_audio_finish):
+            await self._queue.put({"type": "audio_finish", "data": ""})

aichat_sdk/asr/asr_client.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import numpy as np
+import websockets
+
+from aichat_sdk.utils.event_emitter import AsyncEventEmitter
+
+logger = logging.getLogger("aichat_sdk")
+
+SAMPLE_RATE = 16000
+CHUNK_SIZE_MS = 240
+BLOCK_SIZE = SAMPLE_RATE * CHUNK_SIZE_MS // 1000
+
+
+class AsrWebSocketClient(AsyncEventEmitter):
+    """Stream microphone PCM to the ASR WebSocket service."""
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        reconnect_delay: float = 1.0,
+        max_audio_queue: int = 64,
+    ) -> None:
+        super().__init__()
+        self.url = url
+        # 服务端 stt 里的 audio_url 是相对路径（/audio/...），按 ws 地址换成同主机的 http 地址
+        parts = urlsplit(url)
+        self._http_base = urlunsplit(("https" if parts.scheme == "wss" else "http", parts.netloc, "", "", ""))
+        self.reconnect_delay = reconnect_delay
+        self._audio_queue: asyncio.Queue[np.ndarray] = asyncio.Queue(maxsize=max_audio_queue)
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._websocket: Any | None = None
+        self._manager_task: asyncio.Task[None] | None = None
+        self._closing = False
+
+    @property
+    def connected(self) -> bool:
+        return self._websocket is not None
+
+    async def connect(self) -> None:
+        """Connect once, then keep reconnecting in the background if disconnected."""
+        if self._manager_task is not None and not self._manager_task.done():
+            return
+
+        self._loop = asyncio.get_running_loop()
+        self._closing = False
+        websocket = await websockets.connect(self.url, max_size=1024 * 1024)
+        self._websocket = websocket
+        self._manager_task = asyncio.create_task(
+            self._connection_manager(websocket),
+            name="asr-websocket-connection",
+        )
+
+    async def close(self) -> None:
+        self._closing = True
+        task = self._manager_task
+        self._manager_task = None
+        if task is not None:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+        self._websocket = None
+        self._clear_audio_queue()
+
+    def audio_callback(
+        self,
+        indata: np.ndarray,
+        frames: int,
+        time: Any,
+        status: Any,
+    ) -> None:
+        """sounddevice callback: copy mono float samples into the asyncio loop."""
+        del frames, time
+        if status:
+            logger.warning("ASR audio input status: %s", status)
+        loop = self._loop
+        if loop is None or not loop.is_running() or not self.connected:
+            return
+
+        audio = np.asarray(indata)
+        if audio.ndim == 2:
+            audio = audio[:, 0]
+        chunk = np.ascontiguousarray(audio, dtype="<f4").copy()
+        loop.call_soon_threadsafe(self._enqueue_audio, chunk)
+
+    async def send_audio(self, chunk: np.ndarray) -> bool:
+        """Queue one PCM chunk; return False while the service is disconnected."""
+        if not self.connected:
+            return False
+        audio = np.asarray(chunk)
+        if audio.ndim == 2:
+            audio = audio[:, 0]
+        self._enqueue_audio(np.ascontiguousarray(audio, dtype="<f4").copy())
+        return True
+
+    def _enqueue_audio(self, chunk: np.ndarray) -> None:
+        if not self.connected:
+            return
+        if self._audio_queue.full():
+            self._audio_queue.get_nowait()
+            logger.warning("ASR audio queue full; dropped the oldest chunk")
+        self._audio_queue.put_nowait(chunk)
+
+    def _clear_audio_queue(self) -> None:
+        while not self._audio_queue.empty():
+            self._audio_queue.get_nowait()
+
+    async def _connection_manager(self, websocket: Any) -> None:
+        try:
+            while not self._closing:
+                self._websocket = websocket
+                logger.info("ASR WebSocket connected: %s", self.url)
+                await self.emit("connected")
+                try:
+                    await self._run_connection(websocket)
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    logger.exception("ASR WebSocket connection lost")
+                finally:
+                    self._websocket = None
+                    try:
+                        await websocket.close()
+                    except Exception:
+                        logger.exception("failed to close ASR WebSocket")
+                    self._clear_audio_queue()
+
+                if self._closing:
+                    break
+                await self.emit("disconnected")
+                websocket = await self._reconnect()
+        finally:
+            self._websocket = None
+
+    async def _reconnect(self) -> Any:
+        while not self._closing:
+            await asyncio.sleep(self.reconnect_delay)
+            try:
+                websocket = await websockets.connect(
+                    self.url,
+                    max_size=1024 * 1024,
+                )
+                logger.info("ASR WebSocket reconnected: %s", self.url)
+                return websocket
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("ASR WebSocket reconnect failed")
+        raise asyncio.CancelledError
+
+    async def _run_connection(self, websocket: Any) -> None:
+        sender = asyncio.create_task(
+            self._send_audio(websocket),
+            name="asr-websocket-sender",
+        )
+        receiver = asyncio.create_task(
+            self._receive_results(websocket),
+            name="asr-websocket-receiver",
+        )
+        tasks = {sender, receiver}
+        try:
+            done, _ = await asyncio.wait(
+                tasks,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            for task in done:
+                task.result()
+        finally:
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def _send_audio(self, websocket: Any) -> None:
+        while True:
+            chunk = await self._audio_queue.get()
+            await websocket.send(chunk.tobytes())
+
+    async def _receive_results(self, websocket: Any) -> None:
+        async for raw_message in websocket:
+            if not isinstance(raw_message, str):
+                logger.warning("ignored binary ASR server message")
+                continue
+            try:
+                message = json.loads(raw_message)
+            except json.JSONDecodeError:
+                logger.warning("ignored invalid ASR server JSON: %r", raw_message)
+                continue
+
+            message_type = message.get("type")
+            if message_type == "stt":
+                payload = dict(message)
+                payload.pop("type", None)
+                audio_url = payload.get("audio_url")
+                if isinstance(audio_url, str) and audio_url.startswith("/"):
+                    payload["audio_url"] = self._http_base + audio_url
+                await self.emit("stt", payload)
+            elif message_type == "error":
+                await self.emit("error", message)
+            else:
+                logger.warning("ignored unknown ASR server message: %r", message)

aichat_sdk/config.py

@@ -0,0 +1,12 @@
+import os
+
+END_SESSION_TOOL_NAME = "end_session"
+DEFAULT_AGENT_SOUL = """你是一个智能助手，擅长回答各种问题，提供信息，解决问题，并能根据用户需求提供相应的帮助。"""
+
+OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.4")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1")
+ASR_SERVER_WS_URL = os.environ.get("ASR_SERVER_WS_URL", "ws://127.0.0.1:8086/ws")
+
+BYTEDANCE_TTS_APP_ID = os.environ.get("BYTEDANCE_TTS_APP_ID", "")
+BYTEDANCE_TTS_APP_KEY = os.environ.get("BYTEDANCE_TTS_APP_KEY", "")