pipecat-oogam 0.1.0__tar.gz

pipecat_oogam-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+dist/
+build/
+.venv/
+.env

pipecat_oogam-0.1.0/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.1.0 — 2026-11-12
+
+First release. Tested with Pipecat v1.16.0.
+
+- `OogamSTTService` — streaming speech-to-text over
+  `wss://platform.oogam.ai/v1/realtime?intent=transcription`. Sends `finalize`
+  when Pipecat's VAD reports the user stopped speaking, and Oogam confirms it,
+  so transcripts are marked finalized for Pipecat's TTFB metrics. Optional
+  `auto_switch` follows a caller who changes language (`on_language_changed`
+  event). Language changes through `STTUpdateSettingsFrame` apply live, without
+  reconnecting.
+- `OogamTTSService` — streaming text-to-speech from `POST /v1/audio/speech`
+  (`stream: true`, `response_format: "pcm"`, 24 kHz).
+- `OogamLLMService` — Sutra (`sutra-conversation`) through Pipecat's OpenAI
+  service. Function calling is not supported by the endpoint yet.
+- Language helpers mapping Pipecat `Language` values to Oogam's realtime and
+  speech codes.

pipecat_oogam-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dwet Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pipecat_oogam-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.5
+Name: pipecat-oogam
+Version: 0.1.0
+Summary: Oogam speech services for Pipecat — streaming STT with client-driven turn finalize, streaming TTS, and Sutra — for 27 Indian languages and English.
+Project-URL: Homepage, https://oogam.ai/integrations/pipecat
+Project-URL: Documentation, https://oogam.ai/docs/streaming-stt
+Author-email: Dwet Labs <support@dwetlabs.com>
+License: MIT
+License-File: LICENSE
+Keywords: indian-languages,naad,oogam,pipecat,stt,sutra,tts,voice-agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: pipecat-ai<2,>=1.16
+Requires-Dist: websockets>=13
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pipecat-oogam
+
+Oogam speech services for [Pipecat](https://github.com/pipecat-ai/pipecat):
+streaming speech-to-text, streaming text-to-speech and the Sutra conversation
+model, for 27 Indian languages and English.
+
+| Service | Oogam endpoint | What it does |
+|---|---|---|
+| `OogamSTTService` | `wss://platform.oogam.ai/v1/realtime?intent=transcription` | Streaming STT. Final transcripts; finalizes the turn the moment Pipecat's VAD says the user stopped. |
+| `OogamTTSService` | `POST /v1/audio/speech` (`stream: true`, `response_format: "pcm"`) | Streaming TTS — 24 kHz PCM played as it is generated. |
+| `OogamLLMService` | `POST /v1/chat/completions` | Sutra (`sutra-conversation`) through Pipecat's OpenAI service. |
+
+```bash
+pip install pipecat-oogam
+```
+
+Requires Python 3.11+, Pipecat 1.16 or later (1.x) and an Oogam API key
+with the NAAD product enabled. **Tested with Pipecat v1.16.0.**
+
+Maintained by [DWET Labs](https://oogam.ai), the team behind Oogam. Integration
+guide: [oogam.ai/integrations/pipecat](https://oogam.ai/integrations/pipecat).
+
+## Speech-to-text
+
+```python
+from pipecat.transcriptions.language import Language
+from pipecat_oogam import OogamSTTService
+
+stt = OogamSTTService(
+    api_key=os.environ["OOGAM_API_KEY"],
+    settings=OogamSTTService.Settings(language=Language.HI),
+)
+```
+
+**Turn-taking stays with your pipeline.** Oogam's own end-of-turn detection
+waits for 700 ms of silence. With this service you do not wait for it: when
+Pipecat's VAD reports that the user stopped speaking, the service sends Oogam
+`finalize` and Oogam closes the turn straight away. Smart Turn — Pipecat's
+default — or any other turn strategy then decides whether the user's turn is
+really over, exactly as with any other streaming STT. Set
+`finalize_on_vad_stop=False` only if you want Oogam to decide instead.
+
+Each transcript is final. Measured on the live engine (12 Nov 2026): with
+`finalize` the transcript arrives about 0.33 s after the caller stops, against
+about 0.8 s when Oogam waits out its own silence window. If a caller pauses for
+0.8 s or more mid-sentence, Oogam closes a turn there and the rest arrives as a
+second transcript; Pipecat's user aggregator joins them, so Smart Turn still
+decides when the agent replies. (If Oogam ever re-transcribes a turn with
+`replace`, the service pushes only the new words.)
+
+**The language must be given** — Oogam does not auto-detect. To follow a caller
+who switches language mid-call, turn on auto-switch:
+
+```python
+stt = OogamSTTService(
+    api_key=os.environ["OOGAM_API_KEY"],
+    settings=OogamSTTService.Settings(
+        language=Language.HI,
+        auto_switch=True,
+        candidates=[Language.HI, Language.EN_IN, Language.GU],
+    ),
+)
+
+@stt.event_handler("on_language_changed")
+async def on_language_changed(service, from_code, to_code, reason):
+    # e.g. switch the TTS language to match
+    await task.queue_frame(TTSUpdateSettingsFrame(delta=OogamTTSService.Settings(language=to_code)))
+```
+
+Auto-switch acts on Oogam's language hint, which comes after the turn it was
+detected in — so the first sentence after a switch is transcribed in the old
+language, and the switch applies from the next one. Changing `language` with
+an `STTUpdateSettingsFrame` re-pins the live session without reconnecting.
+
+| Setting | Default | |
+|---|---|---|
+| `language` | `Language.HI` | A Pipecat `Language` or an Oogam short code (`hi`, `en-IN`, `bho`). |
+| `vad_end_silence_ms` | Oogam's (700) | 700–5000. Reserved: sent to Oogam, but the current engine does not act on it. |
+| `auto_switch` | `False` | Follow a caller who changes language. |
+| `candidates` | any | Languages a call may switch to. |
+| `min_confidence` | 0.6 | Hint confidence needed to switch. |
+
+Audio is sent at 16 kHz mono PCM16; Pipecat resamples whatever your
+transport delivers.
+
+## Text-to-speech
+
+```python
+async with aiohttp.ClientSession() as session:
+    tts = OogamTTSService(
+        api_key=os.environ["OOGAM_API_KEY"],
+        aiohttp_session=session,
+        settings=OogamTTSService.Settings(voice="aditi", language=Language.HI),
+    )
+```
+
+`voice` is a preset id (`aditi`, `arjun`, …) or a cloned voice id from
+`GET /v1/voices`. Set `language` deliberately: Oogam falls back to Hindi for a
+code it does not know.
+
+## Sutra
+
+```python
+llm = OogamLLMService(api_key=os.environ["OOGAM_API_KEY"])
+```
+
+**No function calling yet.** `/v1/chat/completions` answers a request that
+carries `tools` with `400 tools_not_supported`, so do not register tools on
+this service. For tool use, keep Oogam for STT and TTS and pair them with an
+LLM service that supports tools.
+
+## A complete agent
+
+`examples/voice_agent.py` (in the source distribution, and on
+[oogam.ai/integrations/pipecat](https://oogam.ai/integrations/pipecat#quickstart))
+runs Oogam STT → Sutra → Oogam TTS with Silero VAD and Smart Turn, in the
+browser through Pipecat's development runner:
+
+```bash
+pip install "pipecat-ai[runner,webrtc,silero,local-smart-turn-v3]" pipecat-oogam
+OOGAM_API_KEY=sk-setu-… python examples/voice_agent.py
+```
+
+## Billing
+
+Streaming STT is billed at the speech-to-text rate per second the socket is
+open, TTS per character as on the REST API, and Sutra per token.
+
+## Developing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+Tests that need a running Oogam gateway are skipped unless `OOGAM_DEV_STACK`
+points at one.
+
+## Support
+
+[support@dwetlabs.com](mailto:support@dwetlabs.com) ·
+[Streaming STT reference](https://oogam.ai/docs/streaming-stt)

pipecat_oogam-0.1.0/README.md

@@ -0,0 +1,142 @@
+# pipecat-oogam
+
+Oogam speech services for [Pipecat](https://github.com/pipecat-ai/pipecat):
+streaming speech-to-text, streaming text-to-speech and the Sutra conversation
+model, for 27 Indian languages and English.
+
+| Service | Oogam endpoint | What it does |
+|---|---|---|
+| `OogamSTTService` | `wss://platform.oogam.ai/v1/realtime?intent=transcription` | Streaming STT. Final transcripts; finalizes the turn the moment Pipecat's VAD says the user stopped. |
+| `OogamTTSService` | `POST /v1/audio/speech` (`stream: true`, `response_format: "pcm"`) | Streaming TTS — 24 kHz PCM played as it is generated. |
+| `OogamLLMService` | `POST /v1/chat/completions` | Sutra (`sutra-conversation`) through Pipecat's OpenAI service. |
+
+```bash
+pip install pipecat-oogam
+```
+
+Requires Python 3.11+, Pipecat 1.16 or later (1.x) and an Oogam API key
+with the NAAD product enabled. **Tested with Pipecat v1.16.0.**
+
+Maintained by [DWET Labs](https://oogam.ai), the team behind Oogam. Integration
+guide: [oogam.ai/integrations/pipecat](https://oogam.ai/integrations/pipecat).
+
+## Speech-to-text
+
+```python
+from pipecat.transcriptions.language import Language
+from pipecat_oogam import OogamSTTService
+
+stt = OogamSTTService(
+    api_key=os.environ["OOGAM_API_KEY"],
+    settings=OogamSTTService.Settings(language=Language.HI),
+)
+```
+
+**Turn-taking stays with your pipeline.** Oogam's own end-of-turn detection
+waits for 700 ms of silence. With this service you do not wait for it: when
+Pipecat's VAD reports that the user stopped speaking, the service sends Oogam
+`finalize` and Oogam closes the turn straight away. Smart Turn — Pipecat's
+default — or any other turn strategy then decides whether the user's turn is
+really over, exactly as with any other streaming STT. Set
+`finalize_on_vad_stop=False` only if you want Oogam to decide instead.
+
+Each transcript is final. Measured on the live engine (12 Nov 2026): with
+`finalize` the transcript arrives about 0.33 s after the caller stops, against
+about 0.8 s when Oogam waits out its own silence window. If a caller pauses for
+0.8 s or more mid-sentence, Oogam closes a turn there and the rest arrives as a
+second transcript; Pipecat's user aggregator joins them, so Smart Turn still
+decides when the agent replies. (If Oogam ever re-transcribes a turn with
+`replace`, the service pushes only the new words.)
+
+**The language must be given** — Oogam does not auto-detect. To follow a caller
+who switches language mid-call, turn on auto-switch:
+
+```python
+stt = OogamSTTService(
+    api_key=os.environ["OOGAM_API_KEY"],
+    settings=OogamSTTService.Settings(
+        language=Language.HI,
+        auto_switch=True,
+        candidates=[Language.HI, Language.EN_IN, Language.GU],
+    ),
+)
+
+@stt.event_handler("on_language_changed")
+async def on_language_changed(service, from_code, to_code, reason):
+    # e.g. switch the TTS language to match
+    await task.queue_frame(TTSUpdateSettingsFrame(delta=OogamTTSService.Settings(language=to_code)))
+```
+
+Auto-switch acts on Oogam's language hint, which comes after the turn it was
+detected in — so the first sentence after a switch is transcribed in the old
+language, and the switch applies from the next one. Changing `language` with
+an `STTUpdateSettingsFrame` re-pins the live session without reconnecting.
+
+| Setting | Default | |
+|---|---|---|
+| `language` | `Language.HI` | A Pipecat `Language` or an Oogam short code (`hi`, `en-IN`, `bho`). |
+| `vad_end_silence_ms` | Oogam's (700) | 700–5000. Reserved: sent to Oogam, but the current engine does not act on it. |
+| `auto_switch` | `False` | Follow a caller who changes language. |
+| `candidates` | any | Languages a call may switch to. |
+| `min_confidence` | 0.6 | Hint confidence needed to switch. |
+
+Audio is sent at 16 kHz mono PCM16; Pipecat resamples whatever your
+transport delivers.
+
+## Text-to-speech
+
+```python
+async with aiohttp.ClientSession() as session:
+    tts = OogamTTSService(
+        api_key=os.environ["OOGAM_API_KEY"],
+        aiohttp_session=session,
+        settings=OogamTTSService.Settings(voice="aditi", language=Language.HI),
+    )
+```
+
+`voice` is a preset id (`aditi`, `arjun`, …) or a cloned voice id from
+`GET /v1/voices`. Set `language` deliberately: Oogam falls back to Hindi for a
+code it does not know.
+
+## Sutra
+
+```python
+llm = OogamLLMService(api_key=os.environ["OOGAM_API_KEY"])
+```
+
+**No function calling yet.** `/v1/chat/completions` answers a request that
+carries `tools` with `400 tools_not_supported`, so do not register tools on
+this service. For tool use, keep Oogam for STT and TTS and pair them with an
+LLM service that supports tools.
+
+## A complete agent
+
+`examples/voice_agent.py` (in the source distribution, and on
+[oogam.ai/integrations/pipecat](https://oogam.ai/integrations/pipecat#quickstart))
+runs Oogam STT → Sutra → Oogam TTS with Silero VAD and Smart Turn, in the
+browser through Pipecat's development runner:
+
+```bash
+pip install "pipecat-ai[runner,webrtc,silero,local-smart-turn-v3]" pipecat-oogam
+OOGAM_API_KEY=sk-setu-… python examples/voice_agent.py
+```
+
+## Billing
+
+Streaming STT is billed at the speech-to-text rate per second the socket is
+open, TTS per character as on the REST API, and Sutra per token.
+
+## Developing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+Tests that need a running Oogam gateway are skipped unless `OOGAM_DEV_STACK`
+points at one.
+
+## Support
+
+[support@dwetlabs.com](mailto:support@dwetlabs.com) ·
+[Streaming STT reference](https://oogam.ai/docs/streaming-stt)

pipecat_oogam-0.1.0/examples/voice_agent.py

@@ -0,0 +1,119 @@
+"""A Hindi voice agent on Oogam: Oogam STT → Sutra → Oogam TTS.
+
+Silero VAD and Smart Turn (Pipecat's default turn detector) decide when the
+caller has finished; Oogam STT finalizes each turn the moment the VAD hears
+the caller stop, so there is no extra wait for Oogam's own end-of-turn
+silence. If the caller switches language, the session follows and the agent
+answers in the new language.
+
+    pip install "pipecat-ai[runner,webrtc,silero,local-smart-turn-v3]" pipecat-oogam
+    OOGAM_API_KEY=sk-setu-… python examples/voice_agent.py
+
+Then open the URL it prints and talk.
+"""
+
+import os
+
+import aiohttp
+from loguru import logger
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.frames.frames import LLMRunFrame, TTSUpdateSettingsFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.worker import PipelineParams, PipelineWorker
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams,
+)
+from pipecat.runner.types import RunnerArguments
+from pipecat.runner.utils import create_transport
+from pipecat.transcriptions.language import Language
+from pipecat.transports.base_transport import TransportParams
+
+from pipecat_oogam import OogamLLMService, OogamSTTService, OogamTTSService, to_tts_code
+
+SYSTEM_PROMPT = (
+    "You are a helpful voice assistant for an Indian bank. Answer in the language "
+    "the caller is speaking, in one or two short spoken sentences. No lists, no "
+    "markdown — everything you write is read aloud."
+)
+
+
+async def run_bot(transport, runner_args: RunnerArguments):
+    api_key = os.environ["OOGAM_API_KEY"]
+
+    async with aiohttp.ClientSession() as session:
+        stt = OogamSTTService(
+            api_key=api_key,
+            settings=OogamSTTService.Settings(
+                language=Language.HI,
+                # Follow a caller who switches between these mid-call.
+                auto_switch=True,
+                candidates=[Language.HI, Language.EN_IN, Language.GU],
+            ),
+        )
+        llm = OogamLLMService(api_key=api_key)
+        tts = OogamTTSService(
+            api_key=api_key,
+            aiohttp_session=session,
+            settings=OogamTTSService.Settings(voice="aditi", language=Language.HI),
+        )
+
+        context = LLMContext([{"role": "system", "content": SYSTEM_PROMPT}])
+        aggregators = LLMContextAggregatorPair(
+            context,
+            # Smart Turn v3 is the default stop strategy; the VAD feeds it.
+            user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()),
+        )
+
+        pipeline = Pipeline(
+            [
+                transport.input(),
+                stt,
+                aggregators.user(),
+                llm,
+                tts,
+                transport.output(),
+                aggregators.assistant(),
+            ]
+        )
+        worker = PipelineWorker(
+            pipeline,
+            params=PipelineParams(enable_metrics=True, enable_usage_metrics=True),
+            idle_timeout_secs=runner_args.pipeline_idle_timeout_secs,
+        )
+
+        @stt.event_handler("on_language_changed")
+        async def on_language_changed(service, from_code, to_code, reason):
+            # Speak the language the caller switched to.
+            logger.info(f"caller switched {from_code} -> {to_code}")
+            await worker.queue_frame(
+                TTSUpdateSettingsFrame(delta=OogamTTSService.Settings(language=to_tts_code(to_code)))
+            )
+
+        @transport.event_handler("on_client_connected")
+        async def on_client_connected(transport, client):
+            context.add_message({"role": "user", "content": "Greet the caller briefly in Hindi."})
+            await worker.queue_frames([LLMRunFrame()])
+
+        @transport.event_handler("on_client_disconnected")
+        async def on_client_disconnected(transport, client):
+            await worker.cancel()
+
+        runner = PipelineRunner(handle_sigint=runner_args.handle_sigint)
+        await runner.run(worker)
+
+
+async def bot(runner_args: RunnerArguments):
+    transport = await create_transport(
+        runner_args,
+        {"webrtc": lambda: TransportParams(audio_in_enabled=True, audio_out_enabled=True)},
+    )
+    await run_bot(transport, runner_args)
+
+
+if __name__ == "__main__":
+    from pipecat.runner.run import main
+
+    main()

pipecat_oogam-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pipecat-oogam"
+dynamic = ["version"]
+description = "Oogam speech services for Pipecat — streaming STT with client-driven turn finalize, streaming TTS, and Sutra — for 27 Indian languages and English."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Dwet Labs", email = "support@dwetlabs.com" }]
+keywords = ["pipecat", "oogam", "naad", "sutra", "stt", "tts", "voice-agent", "indian-languages"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+]
+# Built and tested against Pipecat 1.16. The 2.0 line has announced removals,
+# so it is excluded until it is tested.
+dependencies = ["pipecat-ai>=1.16,<2", "aiohttp>=3.9", "websockets>=13"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.23"]
+
+[project.urls]
+Homepage = "https://oogam.ai/integrations/pipecat"
+Documentation = "https://oogam.ai/docs/streaming-stt"
+
+[tool.hatch.version]
+path = "src/pipecat_oogam/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pipecat_oogam"]
+
+# Public source distribution: the package, its unit tests and the example
+# agent only. The internal Voice Lab and the live end-to-end check stay out.
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "src",
+    "tests/test_languages.py",
+    "tests/test_llm.py",
+    "tests/test_stt.py",
+    "tests/test_tts.py",
+    "examples/voice_agent.py",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]

pipecat_oogam-0.1.0/src/pipecat_oogam/__init__.py

@@ -0,0 +1,25 @@
+"""Oogam speech services for Pipecat: streaming STT, streaming TTS and Sutra."""
+
+from pipecat_oogam._version import __version__
+from pipecat_oogam.languages import (
+    SUPPORTED_REALTIME_CODES,
+    from_realtime_code,
+    to_realtime_code,
+    to_tts_code,
+)
+from pipecat_oogam.llm import OogamLLMService
+from pipecat_oogam.stt import OogamSTTService, OogamSTTSettings
+from pipecat_oogam.tts import OogamTTSService, OogamTTSSettings
+
+__all__ = [
+    "__version__",
+    "OogamLLMService",
+    "OogamSTTService",
+    "OogamSTTSettings",
+    "OogamTTSService",
+    "OogamTTSSettings",
+    "SUPPORTED_REALTIME_CODES",
+    "from_realtime_code",
+    "to_realtime_code",
+    "to_tts_code",
+]

pipecat_oogam-0.1.0/src/pipecat_oogam/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pipecat_oogam-0.1.0/src/pipecat_oogam/languages.py

@@ -0,0 +1,109 @@
+"""Language codes for Oogam.
+
+Oogam uses two code systems, and the same language has a code in each:
+
+* the realtime socket (streaming STT) takes short codes — ``hi``, ``gu``,
+  ``en-IN`` — the same ones as Live talk;
+* the REST speech endpoints (TTS) take 3-letter codes — ``HIN``, ``GUJ``,
+  ``ENG``.
+
+Indian English is ``en-IN`` on the socket and ``ENG`` for speech. Plain
+``en`` on the socket is American English.
+
+The table mirrors ``setu-platform/src/constants/languages.ts``. Languages that
+Pipecat's ``Language`` enum does not have (Bhojpuri, Chhattisgarhi, Marwadi,
+Haryanvi, Magahi, Gujarati Kathiyawadi) can be passed as their short code
+string.
+"""
+
+from __future__ import annotations
+
+from pipecat.transcriptions.language import Language
+
+# realtime short code -> TTS 3-letter code
+_LANGUAGES: dict[str, str] = {
+    "hi": "HIN",
+    "en-IN": "ENG",
+    "en": "ENG",
+    "gu": "GUJ",
+    "pa": "PUN",
+    "ne": "NEP",
+    "mr": "MAR",
+    "ta": "TAM",
+    "te": "TEL",
+    "kn": "KAN",
+    "ml": "MAL",
+    "bn": "BEN",
+    "ur": "URD",
+    "or": "ODI",
+    "sd": "SND",
+    "kok": "KON",
+    "as": "ASS",
+    "bho": "BHO",
+    "cha": "CHA",
+    "mai": "MAI",
+    "doi": "DOG",
+    "mwr": "MWR",
+    "bgc": "HAR",
+    "sa": "SAN",
+    "ks": "KAS",
+    "mag": "MAG",
+    "mni": "MNI",
+    "sat": "SAT",
+    "brx": "BRX",
+    "guk": "GUK",
+}
+_BY_LOWER = {code.lower(): code for code in _LANGUAGES}
+_FROM_TTS = {}
+for _short, _tts in _LANGUAGES.items():
+    # ENG maps back to Indian English, the variant Oogam is built for.
+    _FROM_TTS.setdefault(_tts, "en-IN" if _tts == "ENG" else _short)
+
+SUPPORTED_REALTIME_CODES = tuple(_LANGUAGES)
+
+
+def _raw(language: Language | str) -> str:
+    value = language.value if isinstance(language, Language) else str(language)
+    return value.strip()
+
+
+def to_realtime_code(language: Language | str | None) -> str | None:
+    """The realtime-socket code for a language, or None if Oogam does not serve it.
+
+    ``Language.HI`` and ``Language.HI_IN`` → ``hi``; ``Language.EN_IN`` →
+    ``en-IN``; any other English → ``en``; ``"GUJ"`` → ``gu``.
+    """
+    if language is None:
+        return None
+    raw = _raw(language)
+    if not raw:
+        return None
+    if raw.upper() in _FROM_TTS and len(raw) == 3 and raw.isupper():
+        return _FROM_TTS[raw.upper()]
+    low = raw.lower().replace("_", "-")
+    if low in _BY_LOWER:
+        return _BY_LOWER[low]
+    base = low.split("-")[0]
+    if base == "en":
+        return "en-IN" if low == "en-in" else "en"
+    return _BY_LOWER.get(base)
+
+
+def to_tts_code(language: Language | str | None) -> str | None:
+    """The 3-letter speech code for a language, or None if Oogam does not serve it."""
+    short = to_realtime_code(language)
+    return _LANGUAGES.get(short) if short else None
+
+
+def from_realtime_code(code: str | None) -> Language | None:
+    """A Pipecat ``Language`` for a realtime code, when the enum has one."""
+    if not code:
+        return None
+    try:
+        return Language(code)
+    except ValueError:
+        pass
+    try:
+        return Language(code.split("-")[0])
+    except ValueError:
+        return None