fastapi-startkit 0.45.0__tar.gz → 0.47.0__tar.gz

{fastapi_startkit-0.45.0 → fastapi_startkit-0.47.0}/PKG-INFO

@@ -1,9 +1,17 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.45.0
+Version: 0.47.0
 Summary: Fastapi Starter kit components
 Author: Bedram Tamang
 Author-email: Bedram Tamang <tmgbedu@gmail.com>
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Requires-Dist: dotty-dict>=1.3.1
 Requires-Dist: pendulum>=3.1.0,<4.0.0
 Requires-Dist: inflection>=0.5.1
@@ -11,12 +19,11 @@ Requires-Dist: requests>=2.32.5,<3.0.0
 Requires-Dist: cleo>=2.1.0,<3.0.0
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: anthropic>=0.49.0 ; extra == 'ai'
-Requires-Dist: openai>=1.0.0 ; extra == 'ai'
-Requires-Dist: google-generativeai>=0.8.0 ; extra == 'ai'
+Requires-Dist: langchain>=1.0.0 ; extra == 'ai'
+Requires-Dist: langchain-core>=1.0.0 ; extra == 'ai'
 Requires-Dist: faker>=40.13.0 ; extra == 'database'
 Requires-Dist: sqlalchemy[asyncio]>=2.0.38 ; extra == 'database'
-Requires-Dist: fastapi[standard]>=0.124.4,<0.125.0 ; extra == 'fastapi'
+Requires-Dist: fastapi[standard]>=0.124.4 ; extra == 'fastapi'
 Requires-Dist: itsdangerous>=2.2.0 ; extra == 'fastapi'
 Requires-Dist: jinja2>=3.1 ; extra == 'inertia'
 Requires-Dist: markupsafe>=2.0 ; extra == 'inertia'

{fastapi_startkit-0.45.0 → fastapi_startkit-0.47.0}/pyproject.toml

@@ -1,11 +1,21 @@
 [project]
 name = "fastapi-startkit"
-version = "0.45.0"
+version = "0.47.0"
 description = "Fastapi Starter kit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}
 ]
 requires-python = ">=3.12,<4.0"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
 dependencies = [
     "dotty-dict>=1.3.1",
     "pendulum (>=3.1.0,<4.0.0)",
@@ -18,7 +28,7 @@ dependencies = [
 
 [project.optional-dependencies]
 fastapi = [
-    "fastapi[standard] (>=0.124.4,<0.125.0)",
+    "fastapi[standard]>=0.124.4",
     "itsdangerous>=2.2.0",
 ]
 database = [
@@ -48,9 +58,8 @@ inertia = [
 ]
 
 ai = [
-    "anthropic>=0.49.0",
-    "openai>=1.0.0",
-    "google-generativeai>=0.8.0",
+    "langchain>=1.0.0",
+    "langchain-core>=1.0.0",
 ]
 
 [dependency-groups]
@@ -68,6 +77,8 @@ dev = [
     "sqlalchemy[asyncio]>=2.0.38",
     "fastapi[standard]>=0.124.4",
     "faker>=40.13.0",
+    "langchain>=1.0.0",
+    "langchain-core>=1.0.0",
 ]
 
 

fastapi_startkit-0.47.0/src/fastapi_startkit/ai/__init__.py

@@ -0,0 +1,45 @@
+from .agent import Agent
+from .pipeline import Middleware
+from .audio import Audio, AudioResponse
+from .audio_factory import AudioFactory
+from .config.config import AnthropicConfig, ElevenLabsConfig, GoogleConfig, OpenAIConfig
+from .config.ai import AIConfig
+from .decorators import max_steps, max_tokens, model, provider, timeout, top_p
+from .document import Document
+from .fakes import fake_chat_model
+from .image import Image, ImageResponse
+from .image_factory import ImageFactory
+from .providers.ai_provider import AIProvider
+from .response import AgentResponse, AgentSnapshot
+from .testing import AgentBinding, FakeAgent, NoFakeResponse, RecordingAgent
+
+__all__ = [
+    "Agent",
+    "Middleware",
+    "AgentBinding",
+    "AgentResponse",
+    "AgentSnapshot",
+    "AIConfig",
+    "AIProvider",
+    "AnthropicConfig",
+    "FakeAgent",
+    "NoFakeResponse",
+    "RecordingAgent",
+    "Audio",
+    "AudioResponse",
+    "AudioFactory",
+    "Document",
+    "ElevenLabsConfig",
+    "fake_chat_model",
+    "GoogleConfig",
+    "Image",
+    "ImageFactory",
+    "ImageResponse",
+    "OpenAIConfig",
+    "max_steps",
+    "max_tokens",
+    "model",
+    "provider",
+    "timeout",
+    "top_p",
+]

fastapi_startkit-0.47.0/src/fastapi_startkit/ai/agent.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import fnmatch
+from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Optional, Type
+
+from .document import Document
+from .response import AgentResponse, AgentSnapshot
+from .testing import AgentBinding
+
+if TYPE_CHECKING:
+    from langchain_core.tools import BaseTool
+
+
+class Agent:
+    provider: str | None = None
+    model: str | None = None
+    max_steps: int = 10
+    max_tokens: int = 4096
+    timeout: float = 30.0
+    top_p: float = 1.0
+
+    def __init__(self):
+        self._fakes: dict[str, AgentResponse | AgentSnapshot] = {}
+        self._call_log: list[dict] = []
+
+    def messages(self) -> list[dict]:
+        return []
+
+    def instructions(self) -> str | None:
+        return None
+
+    def schema(self) -> Optional[Type]:
+        return None
+
+    def tools(self) -> list[BaseTool]:
+        return []
+
+    def middleware(self) -> list[Callable]:
+        return []
+
+    def provider_options(self) -> dict:
+        return {}
+
+    async def prompt(
+        self,
+        message: str,
+        *,
+        model: str | None = None,
+        attachments: list[Document] | None = None,
+        provider_options: dict | None = None,
+    ) -> AgentResponse:
+        stand_in = self._faked()
+        if stand_in is not None:
+            response = await stand_in.prompt(message, attachments=attachments)
+            self._log_call("prompt", message)
+            return self._apply_schema(response)
+
+        _run_kwargs = dict(
+            model=model,
+            attachments=attachments,
+            provider_options=provider_options,
+        )
+
+        match = self._match_fake(message)
+        if match is not None:
+            if isinstance(match, AgentSnapshot):
+                response = await match.resolve(self, message, **_run_kwargs)
+            else:
+                response = match
+            self._log_call("prompt", message)
+            return self._apply_schema(response)
+
+        messages = self._build_messages(message, attachments)
+        chat_model = self._build_model(model, provider_options)
+
+        response = await self._run_pipeline(chat_model, messages)
+        self._log_call("prompt", message)
+        return self._apply_schema(response)
+
+    async def stream(
+        self,
+        message: str,
+        *,
+        model: str | None = None,
+        provider_options: dict | None = None,
+    ) -> AsyncIterator[str]:
+        self._log_call("stream", message)
+
+        swapped = self._faked()
+        if swapped is not None:
+            if hasattr(swapped, "stream"):
+                async for chunk in swapped.stream(message):
+                    yield chunk
+            else:
+                response = await swapped.prompt(message)
+                yield response.content
+            return
+
+        fake = self._match_fake(message)
+        if fake is not None:
+            if isinstance(fake, AgentSnapshot):
+                response = await fake.resolve(self, message)
+            else:
+                response = fake
+            yield response.content
+            return
+        async for chunk in self._stream(message, model=model, provider_options=provider_options):
+            yield chunk
+
+    @classmethod
+    def fake(cls, responses: dict | None = None) -> "AgentBinding":
+        from .testing import AgentBinding, FakeAgent
+
+        return AgentBinding(cls, FakeAgent(responses))
+
+    @classmethod
+    def record(cls, cassette: str | None = None) -> "AgentBinding":
+        from .testing import AgentBinding, RecordingAgent
+
+        return AgentBinding(cls, RecordingAgent(cls(), cassette))
+
+    @classmethod
+    def _binding(cls) -> Any:
+        from fastapi_startkit.application import app
+
+        container = app()
+        return container.make(cls.__name__) if container.has(cls.__name__) else None
+
+    @classmethod
+    def make(cls) -> "Agent":
+        binding = cls._binding()
+        return binding if binding is not None else cls()
+
+    def _faked(self) -> Any:
+        binding = type(self)._binding()
+        return binding if binding is not self else None
+
+    def assert_prompted(self, times: int | None = None) -> None:
+        calls = [c for c in self._call_log if c["method"] in ("prompt", "stream")]
+        if times is not None:
+            assert len(calls) == times, f"Expected {times} prompt call(s), got {len(calls)}"
+        else:
+            assert len(calls) > 0, "Expected at least one prompt() or stream() call, but none were made"
+
+    def assert_not_prompted(self) -> None:
+        self.assert_prompted(times=0)
+
+    def reset(self) -> "Agent":
+        self._fakes.clear()
+        self._call_log.clear()
+        return self
+
+    def _match_fake(self, message: str) -> Optional[AgentResponse | AgentSnapshot]:
+        for pattern, value in self._fakes.items():
+            if fnmatch.fnmatch(message.lower(), pattern.lower()):
+                return value
+        return None
+
+    def _log_call(self, method: str, message: str) -> None:
+        self._call_log.append({"method": method, "message": message})
+
+    async def _run_pipeline(self, chat_model: Any, messages: list) -> AgentResponse:
+        from .pipeline import Response, build_pipeline  # noqa: PLC0415
+        from .runner import Runner  # noqa: PLC0415
+
+        chain = list(self.middleware())
+        if not chain:
+            return await self._invoke(chat_model, messages)
+
+        def core(model: Any) -> Response:
+            async def _run():
+                result = await Runner(self, model).run(messages)
+                yield result
+
+            return Response(_run)
+
+        pipeline = build_pipeline(chain, core)
+        raw = await pipeline(chat_model)
+        return self._to_agent_response(raw)
+
+    async def _apply_middleware(
+        self,
+        chat_model: Any,
+        final: Callable[[Any], Any],
+    ) -> AgentResponse:
+        chain = list(self.middleware())
+
+        def build(mw_list: list, fn: Callable) -> Callable:
+            if not mw_list:
+                return fn
+            head, *tail = mw_list
+            next_fn = build(tail, fn)
+            mw = head() if isinstance(head, type) else head
+            return lambda model: mw(model, next_fn)
+
+        return await build(chain, final)(chat_model)
+
+    def _build_instruction(self) -> str | None:
+        return self.instructions()
+
+    def _build_messages(
+        self,
+        message: str,
+        attachments: list[Document] | None = None,
+    ) -> list[dict]:
+        messages: list[dict] = []
+
+        instruction = self.instructions()
+        if instruction:
+            messages.append({"role": "system", "content": instruction})
+
+        messages.extend(self.messages() or [])
+
+        if message:
+            messages.append({"role": "user", "content": message})
+
+        if attachments:
+            content: Any = [{"type": "text", "text": message}]
+            for doc in attachments:
+                content.append(doc.to_langchain_block())
+            messages.append({"role": "user", "content": content})
+
+        return messages
+
+    def _build_model(self, model: str | None = None, provider_options: dict | None = None) -> Any:
+        from .model_builder import ModelBuilder  # noqa: PLC0415
+
+        return ModelBuilder(agent=self).build(model, provider_options)
+
+    def _to_agent_response(self, result: Any) -> AgentResponse:
+        messages = result.get("messages", []) if isinstance(result, dict) else []
+        final = messages[-1] if messages else result
+
+        content = getattr(final, "content", "")
+        if not isinstance(content, str):
+            content = str(content)
+
+        tool_calls = list(getattr(final, "tool_calls", None) or [])
+
+        usage: dict[str, Any] = {}
+        meta = getattr(final, "usage_metadata", None)
+        if meta:
+            usage = {"input": meta.get("input_tokens", 0), "output": meta.get("output_tokens", 0)}
+
+        return AgentResponse(content=content, tool_calls=tool_calls, usage=usage, raw=result)
+
+    def _apply_schema(self, response: AgentResponse) -> AgentResponse:
+        schema = self.schema()
+        if schema is not None and response.parsed is None and response.content:
+            response.parsed = self._build_schema(schema, response.content)
+        return response
+
+    @staticmethod
+    def _build_schema(schema: Any, content: str) -> Any:
+        import json  # noqa: PLC0415
+
+        if hasattr(schema, "model_validate_json"):
+            return schema.model_validate_json(content)
+        if hasattr(schema, "model_validate"):
+            return schema.model_validate(json.loads(content))
+        return schema(**json.loads(content))
+
+    async def _invoke(self, chat_model: Any, messages: list[dict]) -> AgentResponse:
+        from .runner import Runner  # noqa: PLC0415
+
+        result = await Runner(self, chat_model).run(messages)
+        return self._to_agent_response(result)
+
+    async def _run(
+        self,
+        message: str,
+        model: str | None = None,
+        attachments: list[Document] | None = None,
+        provider_options: dict | None = None,
+    ) -> AgentResponse:
+        messages = self._build_messages(message, attachments)
+        chat_model = self._build_model(model, provider_options)
+        return await self._invoke(chat_model, messages)
+
+    async def _stream(
+        self,
+        message: str,
+        model: str | None = None,
+        provider_options: dict | None = None,
+    ) -> AsyncIterator[str]:
+        from .pipeline import Response, build_pipeline  # noqa: PLC0415
+        from .runner import StreamRunner  # noqa: PLC0415
+
+        messages = self._build_messages(message)
+        chat_model = self._build_model(model, provider_options)
+        chain = list(self.middleware())
+
+        def core(m: Any) -> Response:
+            return Response(lambda: StreamRunner(self, m).run(messages))
+
+        pipeline = build_pipeline(chain, core) if chain else core
+
+        async for chunk in pipeline(chat_model):
+            yield chunk

{fastapi_startkit-0.45.0 → fastapi_startkit-0.47.0}/src/fastapi_startkit/ai/audio.py

@@ -46,8 +46,6 @@ class AudioResponse:
     def _auto_filename(self) -> str:
         return f"{uuid.uuid4()}.{self._fmt}"
 
-    # ── Storage helpers ────────────────────────────────────────────────────────
-
     async def store(self) -> str:
         """Save to the default private disk with an auto-generated filename."""
         return await self._save(self._auto_filename(), disk="local")
@@ -64,8 +62,6 @@ class AudioResponse:
         """Save to the public disk with a custom filename."""
         return await self._save(name, disk="public")
 
-    # ── Internal ───────────────────────────────────────────────────────────────
-
     async def _save(self, name: str, disk: str = "local") -> str:
         return await asyncio.to_thread(self._save_sync, name, disk)
 
@@ -89,7 +85,7 @@ class AudioResponse:
 class Audio:
     """Fluent builder for text-to-speech generation.
 
-    The active backend is selected from :attr:`~fastapi_startkit.ai.AIConfig.audio_provider`
+    The active backend is selected from :attr:`~fastapi_startkit.ai.AIConfig.default_audio`
     (env: ``AI_AUDIO_PROVIDER``). Defaults to OpenAI TTS.
 
     Usage::
@@ -102,7 +98,6 @@ class Audio:
     Available OpenAI TTS voices: alloy, echo, fable, onyx, nova, shimmer.
     """
 
-    # OpenAI TTS voice presets
     _DEFAULT_VOICE = "alloy"
     _DEFAULT_FEMALE_VOICE = "nova"
     _DEFAULT_MALE_VOICE = "onyx"
@@ -119,8 +114,6 @@ class Audio:
         """Create an :class:`Audio` builder with the given input text."""
         return cls(text)
 
-    # ── Modifier methods (chainable) ───────────────────────────────────────────
-
     def female(self) -> "Audio":
         """Use a female voice (``nova``)."""
         self._voice = self._DEFAULT_FEMALE_VOICE
@@ -158,8 +151,6 @@ class Audio:
         self._response_format = fmt
         return self
 
-    # ── Generation ─────────────────────────────────────────────────────────────
-
     async def generate(self) -> AudioResponse:
         """Call the configured TTS provider and return an :class:`AudioResponse`."""
         provider = self._resolve_provider()
@@ -172,8 +163,6 @@ class Audio:
         )
         return AudioResponse(data=data, fmt=self._response_format)
 
-    # ── Internal ───────────────────────────────────────────────────────────────
-
     def _resolve_provider(self) -> "AudioFactory":
         from .audio_factory import (  # noqa: PLC0415
             ElevenLabsAudioFactory,
@@ -191,7 +180,7 @@ class Audio:
             ai_config = Config.get("ai") if Config is not None else None  # type: ignore[union-attr]
             if ai_config is None:
                 raise RuntimeError("Config not available")
-            provider_name = ai_config.audio_provider
+            provider_name = ai_config.default_audio
             openai_cfg = ai_config.providers.get("openai")
             if openai_cfg:
                 api_key = openai_cfg.key or None

{fastapi_startkit-0.45.0 → fastapi_startkit-0.47.0}/src/fastapi_startkit/ai/audio_factory.py

@@ -3,7 +3,7 @@
 Providers implement the :class:`AudioFactory` ABC so that the
 :class:`~fastapi_startkit.ai.Audio` builder is not hard-wired to a single
 vendor.  Select the active provider via ``AI_AUDIO_PROVIDER`` in your
-``.env`` (or ``AIConfig.audio_provider``).
+``.env`` (or ``AIConfig.default_audio``).
 
 Supported providers
 -------------------
@@ -100,7 +100,6 @@ class GoogleAudioFactory(AudioFactory):
     because Gemini TTS yields raw PCM16 which is wrapped in a WAV container.
     """
 
-    # Map OpenAI-style voice aliases → Google Gemini voice names
     _VOICE_MAP: dict[str, str] = {
         "nova": "Aoede",
         "alloy": "Kore",
@@ -149,7 +148,6 @@ class GoogleAudioFactory(AudioFactory):
             ),
         )
 
-        # Gemini TTS returns raw PCM16 samples — wrap in WAV container
         pcm_data = response.candidates[0].content.parts[0].inline_data.data
         return _pcm_to_wav(pcm_data)
 
@@ -187,14 +185,13 @@ class ElevenLabsAudioFactory(AudioFactory):
         not currently supported by ElevenLabs.
     """
 
-    # Map OpenAI-style aliases → ElevenLabs voice IDs
     _VOICE_MAP: dict[str, str] = {
-        "nova": "21m00Tcm4TlvDq8ikWAM",  # Rachel — female
-        "alloy": "EXAVITQu4vr4xnSDxMaL",  # Bella  — female
-        "shimmer": "MF3mGyEYCl7XYWbV9V6O",  # Elli   — female
-        "onyx": "pNInz6obpgDQGcFmaJgB",  # Adam   — male
-        "echo": "ErXwobaYiN019PkySvjV",  # Antoni — male
-        "fable": "VR6AewLTigWG4xSOukaG",  # Arnold — male
+        "nova": "21m00Tcm4TlvDq8ikWAM",
+        "alloy": "EXAVITQu4vr4xnSDxMaL",
+        "shimmer": "MF3mGyEYCl7XYWbV9V6O",
+        "onyx": "pNInz6obpgDQGcFmaJgB",
+        "echo": "ErXwobaYiN019PkySvjV",
+        "fable": "VR6AewLTigWG4xSOukaG",
     }
 
     def __init__(self, api_key: str | None = None):
@@ -223,9 +220,6 @@ class ElevenLabsAudioFactory(AudioFactory):
         return b"".join(audio_chunks)
 
 
-# ─── PCM → WAV helper ─────────────────────────────────────────────────────────
-
-
 def _pcm_to_wav(
     pcm_data: bytes,
     sample_rate: int = 24000,
@@ -248,7 +242,7 @@ def _pcm_to_wav(
         b"WAVE",
         b"fmt ",
         16,
-        1,  # PCM
+        1,
         channels,
         sample_rate,
         byte_rate,

fastapi_startkit-0.47.0/src/fastapi_startkit/ai/config/ai.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+
+from fastapi_startkit.environment import env
+
+from fastapi_startkit.ai import AnthropicConfig, ElevenLabsConfig, GoogleConfig, OpenAIConfig
+
+
+@dataclass
+class AIConfig:
+    """Top-level AI configuration — selects the default provider per modality and holds per-provider configs."""
+
+    default: str = field(default_factory=lambda: env("AI_PROVIDER", "google"))
+    default_image: str = field(default_factory=lambda: env("AI_DEFAULT_IMAGE_PROVIDER", "openai"))
+    default_audio: str = field(default_factory=lambda: env("AI_DEFAULT_AUDIO_PROVIDER", "openai"))
+    default_transcribe: str = field(default_factory=lambda: env("AI_DEFAULT_TRANSCRIBE_PROVIDER", "openai"))
+
+    providers: dict = field(
+        default_factory=lambda: {
+            "google": GoogleConfig(),
+            "openai": OpenAIConfig(),
+            "anthropic": AnthropicConfig(),
+            "elevenlabs": ElevenLabsConfig(),
+        }
+    )

{fastapi_startkit-0.45.0/src/fastapi_startkit/ai → fastapi_startkit-0.47.0/src/fastapi_startkit/ai/config}/config.py

@@ -1,5 +1,3 @@
-"""AI configuration dataclasses for the FastAPI Startkit AI module."""
-
 from __future__ import annotations
 
 from dataclasses import dataclass, field
@@ -15,6 +13,12 @@ class AnthropicConfig:
     key: str = field(default_factory=lambda: env("ANTHROPIC_API_KEY", ""))
     url: str = field(default_factory=lambda: env("ANTHROPIC_BASE_URL", "https://api.anthropic.com"))
 
+    models: dict = field(
+        default_factory=lambda: {
+            "default": "claude-sonnet-4-6",
+        }
+    )
+
 
 @dataclass
 class OpenAIConfig:
@@ -24,6 +28,13 @@ class OpenAIConfig:
     key: str = field(default_factory=lambda: env("OPENAI_API_KEY", ""))
     url: str = field(default_factory=lambda: env("OPENAI_BASE_URL", "https://api.openai.com/v1"))
 
+    models: dict = field(
+        default_factory=lambda: {
+            "default": "gpt-4o",
+            "default_image": "dall-e-3",
+        }
+    )
+
 
 @dataclass
 class GoogleConfig:
@@ -32,6 +43,13 @@ class GoogleConfig:
     driver: str = "google"
     key: str = field(default_factory=lambda: env("GEMINI_API_KEY", "") or env("GOOGLE_API_KEY", ""))
 
+    models: dict = field(
+        default_factory=lambda: {
+            "default": "gemini-2.5-flash-lite",
+            "default_image": "imagen-3.0-generate-002",
+        }
+    )
+
 
 @dataclass
 class ElevenLabsConfig:
@@ -40,22 +58,9 @@ class ElevenLabsConfig:
     driver: str = "elevenlabs"
     key: str = field(default_factory=lambda: env("ELEVENLABS_API_KEY", ""))
 
-
-@dataclass
-class AIConfig:
-    """Top-level AI configuration — selects the default provider and holds per-provider configs."""
-
-    default: str = field(default_factory=lambda: env("AI_PROVIDER", "google"))
-
-    providers: dict = field(
+    models: dict = field(
         default_factory=lambda: {
-            "openai": OpenAIConfig(),
-            "anthropic": AnthropicConfig(),
-            "google": GoogleConfig(),
-            "elevenlabs": ElevenLabsConfig(),
+            "default_audio": "eleven_multilingual_v2",
+            "default_transcribe": "scribe_v1",
         }
     )
-
-    # Media-generation provider selection
-    image_provider: str = field(default_factory=lambda: env("AI_IMAGE_PROVIDER", "openai"))
-    audio_provider: str = field(default_factory=lambda: env("AI_AUDIO_PROVIDER", "openai"))