zeroruntime 0.1.0__tar.gz

zeroruntime-0.1.0/LICENSE

@@ -0,0 +1,54 @@
+Zeroruntime SDK — Proprietary License
+
+Copyright (c) 2026 Zujo Tech Pvt Ltd. All rights reserved.
+
+This software, including its source code, object code, and accompanying
+documentation (collectively, the "Software"), is the proprietary and
+confidential property of Zujo Tech Pvt Ltd ("Licensor"). The Software is
+licensed, not sold. No ownership rights are transferred to you. "Zero Runtime"
+and "ZRT" are products and services of Zujo Tech Pvt Ltd.
+
+1. License Grant. Subject to your continued compliance with this License (and
+   with any separate written agreement you have entered into with Licensor),
+   Licensor grants you a limited, non-exclusive, non-transferable, non-
+   sublicensable, revocable license to install and use the Software solely to
+   develop and operate applications that connect to and interoperate with the
+   Zero Runtime service.
+
+2. Restrictions. Except to the extent expressly permitted in Section 1, by a
+   separate written agreement with Licensor, or by applicable law that cannot
+   be contractually waived, you may NOT:
+     (a) copy, modify, adapt, translate, or create derivative works of the
+         Software;
+     (b) distribute, publish, sublicense, sell, rent, lease, lend, or
+         otherwise make the Software available to any third party;
+     (c) reverse engineer, decompile, or disassemble the Software, or attempt
+         to derive its source code where not provided;
+     (d) use the Software to build or operate a product or service that
+         competes with the Zero Runtime service; or
+     (e) remove, obscure, or alter any proprietary notices, labels, or marks
+         on or in the Software.
+
+3. Ownership. The Software is protected by copyright and other intellectual
+   property laws and treaties. Licensor and its licensors retain all right,
+   title, and interest in and to the Software, including all intellectual
+   property rights therein.
+
+4. Termination. This License is effective until terminated. It terminates
+   automatically, without notice, if you breach any of its terms. Upon
+   termination you must cease all use of the Software and destroy all copies
+   in your possession or control.
+
+5. No Warranty. THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE", WITHOUT
+   WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+   WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+   NONINFRINGEMENT.
+
+6. Limitation of Liability. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT
+   SHALL LICENSOR BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
+   CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR ANY LOSS OF PROFITS, DATA, OR USE,
+   ARISING OUT OF OR RELATED TO THIS LICENSE OR THE SOFTWARE, WHETHER IN
+   CONTRACT, TORT, OR OTHERWISE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+   DAMAGES.
+
+For licensing inquiries, contact: support@videosdk.live

zeroruntime-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: zeroruntime
+Version: 0.1.0
+Summary: Build real-time voice agents in Python.
+Author: ZeroRuntime
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/ZeroRuntimeAI/zeroruntime-py
+Project-URL: Repository, https://github.com/ZeroRuntimeAI/zeroruntime-py
+Project-URL: Issues, https://github.com/ZeroRuntimeAI/zeroruntime-py/issues
+Keywords: voice,voice-agents,realtime,speech,stt,tts,llm,grpc
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: protobuf<8.0,>=7.35.1
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: mcp>=1.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: grpcio-tools==1.83.0; extra == "dev"
+Dynamic: license-file
+
+# zeroruntime
+
+Build real-time voice agents in Python. You describe the agent — instructions,
+tools, and a pipeline of providers — and the runtime runs it.
+
+## Install
+
+```bash
+pip install zeroruntime
+```
+
+or pin the version:
+
+```bash
+pip install zeroruntime==0.1.0
+```
+
+Requires Python 3.10 or newer.
+
+Most providers need no extra: their credential is a string you set in the
+environment, so the base install is enough.
+
+## Quickstart
+
+```python
+import zrt
+from zrt import Agent, Pipeline, Room, function_tool
+from zrt.inference import TurnDetector
+from zrt.plugins import CartesiaTTS, DeepgramSTT, GoogleLLM, SileroVAD
+
+AGENT_ID = "cascade-basic-agent"
+
+
+class VoiceAgent(Agent):
+    def __init__(self) -> None:
+        super().__init__(
+            agent_id=AGENT_ID,
+            instructions="You are a helpful voice assistant.",
+            pipeline=Pipeline(
+                stt=DeepgramSTT(),
+                llm=GoogleLLM(),
+                tts=CartesiaTTS(),
+                vad=SileroVAD(),
+                turn_detector=TurnDetector(),
+            ),
+        )
+
+    async def on_enter(self) -> None:
+        await self.session.say("Hello, how can I help you today?")
+
+    @function_tool
+    async def get_weather(self, latitude: str, longitude: str) -> dict:
+        """Fetch the current weather for a location.
+
+        Args:
+            latitude: Latitude of the location. Estimate it; do not ask.
+            longitude: Longitude of the location. Estimate it; do not ask.
+        """
+        return {"latitude": latitude, "longitude": longitude, "temperature_c": 28}
+
+
+def invoke_agent() -> None:
+    zrt.invoke(AGENT_ID, room=Room(name="Cascade Agent", playground=True))
+
+
+if __name__ == "__main__":
+    zrt.serve(VoiceAgent, on_ready=invoke_agent)
+```
+
+Run it and the playground URL is printed once, on stdout. Open it to talk to
+the agent.
+
+## Credentials
+
+Set your runtime token in the environment before serving:
+
+```bash
+export ZERORUNTIME_AUTH_TOKEN="..."
+```
+
+Vendor keys go in the environment too, one per provider you use — each provider
+names the variable it reads when the key is missing.
+
+## Providers
+
+`zrt.plugins` calls the vendor directly with your key on your account.
+`zrt.inference` reaches a subset of the same providers through the runtime
+gateway instead. The names mirror each other, so swapping the import swaps who
+makes the call and who is billed:
+
+```python
+from zrt.plugins import DeepgramSTT    # your Deepgram account
+from zrt.inference import DeepgramSTT  # through the gateway
+```

zeroruntime-0.1.0/README.md

@@ -0,0 +1,94 @@
+# zeroruntime
+
+Build real-time voice agents in Python. You describe the agent — instructions,
+tools, and a pipeline of providers — and the runtime runs it.
+
+## Install
+
+```bash
+pip install zeroruntime
+```
+
+or pin the version:
+
+```bash
+pip install zeroruntime==0.1.0
+```
+
+Requires Python 3.10 or newer.
+
+Most providers need no extra: their credential is a string you set in the
+environment, so the base install is enough.
+
+## Quickstart
+
+```python
+import zrt
+from zrt import Agent, Pipeline, Room, function_tool
+from zrt.inference import TurnDetector
+from zrt.plugins import CartesiaTTS, DeepgramSTT, GoogleLLM, SileroVAD
+
+AGENT_ID = "cascade-basic-agent"
+
+
+class VoiceAgent(Agent):
+    def __init__(self) -> None:
+        super().__init__(
+            agent_id=AGENT_ID,
+            instructions="You are a helpful voice assistant.",
+            pipeline=Pipeline(
+                stt=DeepgramSTT(),
+                llm=GoogleLLM(),
+                tts=CartesiaTTS(),
+                vad=SileroVAD(),
+                turn_detector=TurnDetector(),
+            ),
+        )
+
+    async def on_enter(self) -> None:
+        await self.session.say("Hello, how can I help you today?")
+
+    @function_tool
+    async def get_weather(self, latitude: str, longitude: str) -> dict:
+        """Fetch the current weather for a location.
+
+        Args:
+            latitude: Latitude of the location. Estimate it; do not ask.
+            longitude: Longitude of the location. Estimate it; do not ask.
+        """
+        return {"latitude": latitude, "longitude": longitude, "temperature_c": 28}
+
+
+def invoke_agent() -> None:
+    zrt.invoke(AGENT_ID, room=Room(name="Cascade Agent", playground=True))
+
+
+if __name__ == "__main__":
+    zrt.serve(VoiceAgent, on_ready=invoke_agent)
+```
+
+Run it and the playground URL is printed once, on stdout. Open it to talk to
+the agent.
+
+## Credentials
+
+Set your runtime token in the environment before serving:
+
+```bash
+export ZERORUNTIME_AUTH_TOKEN="..."
+```
+
+Vendor keys go in the environment too, one per provider you use — each provider
+names the variable it reads when the key is missing.
+
+## Providers
+
+`zrt.plugins` calls the vendor directly with your key on your account.
+`zrt.inference` reaches a subset of the same providers through the runtime
+gateway instead. The names mirror each other, so swapping the import swaps who
+makes the call and who is billed:
+
+```python
+from zrt.plugins import DeepgramSTT    # your Deepgram account
+from zrt.inference import DeepgramSTT  # through the gateway
+```

zeroruntime-0.1.0/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zeroruntime"
+dynamic = ["version"]
+description = "Build real-time voice agents in Python."
+readme = "README.md"
+requires-python = ">=3.10"          # dataclasses kw_only; the whole provider layer needs it
+license = "LicenseRef-Proprietary"
+
+license-files = ["LICENSE"]
+authors = [{ name = "ZeroRuntime" }]
+keywords = ["voice", "voice-agents", "realtime", "speech", "stt", "tts", "llm", "grpc"]
+
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Multimedia :: Sound/Audio :: Speech",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+
+# The base install describes sessions and carries credentials. It does not run
+# agents: no audio stack, no ML runtime, and -- by construction -- no vendor SDK.
+# Anything added here is installed on every developer laptop that pip installs
+# this package, so the list is closed and tests/test_packaging.py pins it.
+dependencies = [
+  # Both floored by the grpcio-tools pin in [dev], and for the same reason:
+  # protoc 1.83.0 stamps its own version into the generated code, and a runtime
+  # older than the gencode refuses to load on the first wire import. Declaring a
+  # lower floor makes the package installable but not usable.
+  #
+  #   zrt/_wire/*_pb2.py       ValidateProtobufRuntimeVersion(7, 35, 1)
+  #   zrt/_wire/*_pb2_grpc.py  GRPC_GENERATED_VERSION = '1.83.0'
+  #
+  # grpcio said >=1.81.0 while the gencode demanded 1.83.0, so an environment
+  # holding 1.82.0 resolved happily and then died at `serve()` with "the grpc
+  # package installed is at version 1.82.0, but the generated code ... depends
+  # on grpcio>=1.83.0". Keep both floors equal to what scripts/gen.py stamped.
+  "grpcio>=1.83.0",
+  "protobuf>=7.35.1,<8.0",
+  "aiohttp>=3.9.0",
+  "python-dotenv>=1.0",
+  "mcp>=1.28.0",
+]
+
+[project.scripts]
+zrt = "zrt._cli:main"
+
+[project.urls]
+Homepage = "https://github.com/ZeroRuntimeAI/zeroruntime-py"
+Repository = "https://github.com/ZeroRuntimeAI/zeroruntime-py"
+Issues = "https://github.com/ZeroRuntimeAI/zeroruntime-py/issues"
+
+[project.optional-dependencies]
+
+# Not shipped to users. grpcio-tools carries protoc for scripts/gen.py; without
+# it the wire stage of `gen.py --check` reports itself unavailable rather than
+# passing silently.
+#
+# grpcio-tools is pinned exactly, not floored: `gen.py --check` compares
+# generated bytes, and two protoc versions do not agree on them. A floor turns
+# every grpcio-tools release into a red build on a file nobody touched. Moving
+# the pin is a deliberate commit that regenerates zrt/_wire/ alongside it, and
+# the pinned version decides the `protobuf` floor above -- 1.83.0 stamps the
+# gencode as requiring runtime >= 7.35.1.
+dev = [
+  "pytest>=8.0",
+  "grpcio-tools==1.83.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["zrt*"]
+namespaces = false
+
+[tool.setuptools.package-data]
+zrt = ["py.typed"]
+
+[tool.setuptools.dynamic]
+# Read statically out of zrt/_version.py. Pointing this at `zrt.__version__`
+# also works but makes the build import the package.
+version = { attr = "zrt._version.__version__" }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

zeroruntime-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zeroruntime-0.1.0/zeroruntime.egg-info/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: zeroruntime
+Version: 0.1.0
+Summary: Build real-time voice agents in Python.
+Author: ZeroRuntime
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/ZeroRuntimeAI/zeroruntime-py
+Project-URL: Repository, https://github.com/ZeroRuntimeAI/zeroruntime-py
+Project-URL: Issues, https://github.com/ZeroRuntimeAI/zeroruntime-py/issues
+Keywords: voice,voice-agents,realtime,speech,stt,tts,llm,grpc
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: protobuf<8.0,>=7.35.1
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: mcp>=1.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: grpcio-tools==1.83.0; extra == "dev"
+Dynamic: license-file
+
+# zeroruntime
+
+Build real-time voice agents in Python. You describe the agent — instructions,
+tools, and a pipeline of providers — and the runtime runs it.
+
+## Install
+
+```bash
+pip install zeroruntime
+```
+
+or pin the version:
+
+```bash
+pip install zeroruntime==0.1.0
+```
+
+Requires Python 3.10 or newer.
+
+Most providers need no extra: their credential is a string you set in the
+environment, so the base install is enough.
+
+## Quickstart
+
+```python
+import zrt
+from zrt import Agent, Pipeline, Room, function_tool
+from zrt.inference import TurnDetector
+from zrt.plugins import CartesiaTTS, DeepgramSTT, GoogleLLM, SileroVAD
+
+AGENT_ID = "cascade-basic-agent"
+
+
+class VoiceAgent(Agent):
+    def __init__(self) -> None:
+        super().__init__(
+            agent_id=AGENT_ID,
+            instructions="You are a helpful voice assistant.",
+            pipeline=Pipeline(
+                stt=DeepgramSTT(),
+                llm=GoogleLLM(),
+                tts=CartesiaTTS(),
+                vad=SileroVAD(),
+                turn_detector=TurnDetector(),
+            ),
+        )
+
+    async def on_enter(self) -> None:
+        await self.session.say("Hello, how can I help you today?")
+
+    @function_tool
+    async def get_weather(self, latitude: str, longitude: str) -> dict:
+        """Fetch the current weather for a location.
+
+        Args:
+            latitude: Latitude of the location. Estimate it; do not ask.
+            longitude: Longitude of the location. Estimate it; do not ask.
+        """
+        return {"latitude": latitude, "longitude": longitude, "temperature_c": 28}
+
+
+def invoke_agent() -> None:
+    zrt.invoke(AGENT_ID, room=Room(name="Cascade Agent", playground=True))
+
+
+if __name__ == "__main__":
+    zrt.serve(VoiceAgent, on_ready=invoke_agent)
+```
+
+Run it and the playground URL is printed once, on stdout. Open it to talk to
+the agent.
+
+## Credentials
+
+Set your runtime token in the environment before serving:
+
+```bash
+export ZERORUNTIME_AUTH_TOKEN="..."
+```
+
+Vendor keys go in the environment too, one per provider you use — each provider
+names the variable it reads when the key is missing.
+
+## Providers
+
+`zrt.plugins` calls the vendor directly with your key on your account.
+`zrt.inference` reaches a subset of the same providers through the runtime
+gateway instead. The names mirror each other, so swapping the import swaps who
+makes the call and who is billed:
+
+```python
+from zrt.plugins import DeepgramSTT    # your Deepgram account
+from zrt.inference import DeepgramSTT  # through the gateway
+```

zeroruntime-0.1.0/zeroruntime.egg-info/SOURCES.txt

@@ -0,0 +1,90 @@
+LICENSE
+README.md
+pyproject.toml
+zeroruntime.egg-info/PKG-INFO
+zeroruntime.egg-info/SOURCES.txt
+zeroruntime.egg-info/dependency_links.txt
+zeroruntime.egg-info/entry_points.txt
+zeroruntime.egg-info/requires.txt
+zeroruntime.egg-info/top_level.txt
+zrt/__init__.py
+zrt/_cli.py
+zrt/_cli_download.py
+zrt/_invoke.py
+zrt/_log_format.py
+zrt/_mcp_client.py
+zrt/_serve.py
+zrt/_spec.py
+zrt/_version.py
+zrt/py.typed
+zrt/_client/__init__.py
+zrt/_client/auth.py
+zrt/_client/channel.py
+zrt/_client/credentials.py
+zrt/_client/registry.py
+zrt/_client/tool_bridge.py
+zrt/_client/translate.py
+zrt/_plugins/__init__.py
+zrt/_plugins/_registry.py
+zrt/_plugins/anam.py
+zrt/_plugins/anthropic.py
+zrt/_plugins/assemblyai.py
+zrt/_plugins/aws.py
+zrt/_plugins/azure.py
+zrt/_plugins/cambai.py
+zrt/_plugins/cartesia.py
+zrt/_plugins/cerebras.py
+zrt/_plugins/cometapi.py
+zrt/_plugins/deepgram.py
+zrt/_plugins/elevenlabs.py
+zrt/_plugins/gladia.py
+zrt/_plugins/google.py
+zrt/_plugins/groq.py
+zrt/_plugins/humeai.py
+zrt/_plugins/inworldai.py
+zrt/_plugins/lmnt.py
+zrt/_plugins/murfai.py
+zrt/_plugins/navana.py
+zrt/_plugins/neuphonic.py
+zrt/_plugins/nvidia.py
+zrt/_plugins/openai.py
+zrt/_plugins/papla.py
+zrt/_plugins/resemble.py
+zrt/_plugins/rime.py
+zrt/_plugins/rnnoise.py
+zrt/_plugins/sarvamai.py
+zrt/_plugins/silero.py
+zrt/_plugins/simli.py
+zrt/_plugins/smallestai.py
+zrt/_plugins/speechify.py
+zrt/_plugins/ultravox.py
+zrt/_plugins/xai.py
+zrt/_wire/__init__.py
+zrt/_wire/zeroruntime_pb2.py
+zrt/_wire/zeroruntime_pb2.pyi
+zrt/_wire/zeroruntime_pb2_grpc.py
+zrt/core/__init__.py
+zrt/core/_tasks.py
+zrt/core/agent.py
+zrt/core/context.py
+zrt/core/enums.py
+zrt/core/errors.py
+zrt/core/events.py
+zrt/core/mcp.py
+zrt/core/pipeline.py
+zrt/core/room.py
+zrt/core/session.py
+zrt/core/stt_stream.py
+zrt/core/tools.py
+zrt/core/transfer.py
+zrt/core/tuning.py
+zrt/core/utterance.py
+zrt/inference/__init__.py
+zrt/inference/_registry.py
+zrt/inference/denoise.py
+zrt/inference/llm.py
+zrt/inference/realtime.py
+zrt/inference/stt.py
+zrt/inference/tts.py
+zrt/inference/turn.py
+zrt/plugins/__init__.py

zeroruntime-0.1.0/zeroruntime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zeroruntime-0.1.0/zeroruntime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zrt = zrt._cli:main

zeroruntime-0.1.0/zeroruntime.egg-info/requires.txt

@@ -0,0 +1,9 @@
+grpcio>=1.83.0
+protobuf<8.0,>=7.35.1
+aiohttp>=3.9.0
+python-dotenv>=1.0
+mcp>=1.28.0
+
+[dev]
+pytest>=8.0
+grpcio-tools==1.83.0

zeroruntime-0.1.0/zeroruntime.egg-info/top_level.txt

@@ -0,0 +1 @@
+zrt

zeroruntime-0.1.0/zrt/__init__.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+from ._version import __version__
+
+_LAZY: dict[str, tuple[str, str]] = {
+    "Agent": ("zrt.core.agent", "Agent"),
+    "AgentContext": ("zrt.core.context", "AgentContext"),
+    "BackgroundAudio": ("zrt.core.agent", "BackgroundAudio"),
+    "CallSummary": ("zrt.core.agent", "CallSummary"),
+    "Pipeline": ("zrt.core.pipeline", "Pipeline"),
+    "NO_CHANGE": ("zrt.core.pipeline", "NO_CHANGE"),
+    "EOUConfig": ("zrt.core.tuning", "EOUConfig"),
+    "InterruptConfig": ("zrt.core.tuning", "InterruptConfig"),
+    "function_tool": ("zrt.core.tools", "function_tool"),
+    "MCPServerStdio": ("zrt.core.mcp", "MCPServerStdio"),
+    "MCPServerHTTP": ("zrt.core.mcp", "MCPServerHTTP"),
+    "SIPDestination": ("zrt.core.transfer", "SIPDestination"),
+    "WarmTransferConfig": ("zrt.core.transfer", "WarmTransferConfig"),
+    "WarmTransferPhase": ("zrt.core.transfer", "WarmTransferPhase"),
+    "WarmTransferResult": ("zrt.core.transfer", "WarmTransferResult"),
+    "run_stt": ("zrt.core.stt_stream", "run_stt"),
+    "Room": ("zrt.core.room", "Room"),
+    "UNSET": ("zrt.core.room", "UNSET"),
+    "Sip": ("zrt.core.room", "Sip"),
+    "Observability": ("zrt.core.room", "Observability"),
+    "Exporter": ("zrt.core.room", "Exporter"),
+    "Session": ("zrt.core.session", "Session"),
+    "UtteranceHandle": ("zrt.core.utterance", "UtteranceHandle"),
+    "PronunciationRule": ("zrt.core.pipeline", "PronunciationRule"),
+    "ContextWindow": ("zrt.core.pipeline", "ContextWindow"),
+    "RoomMessage": ("zrt.core.session", "RoomMessage"),
+    "Participant": ("zrt.core.session", "Participant"),
+    "serve": ("zrt._serve", "serve"),
+    "invoke": ("zrt._invoke", "invoke"),
+    "ZeroRuntimeChannel": ("zrt._client.channel", "ZeroRuntimeChannel"),
+    "ZrtError": ("zrt.core.errors", "ZrtError"),
+    "SessionRejected": ("zrt.core.errors", "SessionRejected"),
+    "ProviderUnavailable": ("zrt.core.errors", "ProviderUnavailable"),
+    "ZeroRuntimeUnreachable": ("zrt.core.errors", "ZeroRuntimeUnreachable"),
+    "ToolTimeout": ("zrt.core.errors", "ToolTimeout"),
+    "AgentState": ("zrt.core.enums", "AgentState"),
+    "UserState": ("zrt.core.enums", "UserState"),
+    "PipelineMode": ("zrt.core.enums", "PipelineMode"),
+    "ChatRole": ("zrt.core.enums", "ChatRole"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        module, attr = _LAZY[name]
+    except KeyError:
+        raise AttributeError(f"module 'zrt' has no attribute {name!r}") from None
+    value = getattr(importlib.import_module(module), attr)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(_LAZY)
+
+
+__all__ = [*sorted(_LAZY), "__version__"]