zrt 0.0.1b1__tar.gz

zrt-0.0.1b1/LICENSE

@@ -0,0 +1,54 @@
+ZRT Python 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

zrt-0.0.1b1/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include zrt/py.typed
+recursive-exclude * __pycache__
+recursive-exclude * *.py[cod]

zrt-0.0.1b1/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: zrt
+Version: 0.0.1b1
+Summary: Build real-time AI voice agents in Python. Zero Runtime runs the speech-to-speech pipeline (STT, LLM, TTS) for you.
+Author-email: Zujo Tech Pvt Ltd <support@videosdk.live>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://zeroruntime.ai/
+Project-URL: Examples, https://github.com/ZeroRuntimeAI/zrt-python-sdk-examples
+Keywords: voice-agents,voice-ai,ai-voice-agent,conversational-ai,voice-assistant,speech-to-speech,realtime-voice,voicebot,llm,stt,tts,speech-to-text,text-to-speech,telephony,sip,webrtc,zero-runtime
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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 :: Scientific/Engineering :: Artificial Intelligence
+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.81.0
+Requires-Dist: protobuf>=6.31.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: vision
+Requires-Dist: Pillow>=10.0; extra == "vision"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: grpcio-tools>=1.81.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# ZRT — Zero Runtime Python SDK
+
+**Build real-time AI voice agents in Python — without running the infrastructure.**
+You write the agent (instructions, tools, logic); **Zero Runtime** runs the live
+speech-to-speech pipeline — speech-to-text → LLM → text-to-speech, with turn
+detection, denoising, and interruptions — at low latency in the cloud.
+
+> **Write the agent. We run the runtime.**
+
+## A different kind of voice SDK
+
+Most voice frameworks make you run the hard part — media servers, GPUs, turn-taking,
+autoscaling. No-code platforms hide all that but lock you into a dashboard.
+**Zero Runtime is the middle:** real Python and your own providers, with none of the
+real-time infrastructure to operate.
+
+| | Self-hosted frameworks | No-code platforms | **Zero Runtime** |
+|---|:---:|:---:|:---:|
+| Write real Python + custom tools | ✅ | ❌ (dashboard) | ✅ |
+| Run media servers / GPUs / scaling | ❌ *you run it* | ✅ managed | ✅ managed |
+| Swap any STT / LLM / TTS provider | ✅ | limited | ✅ |
+| Low-latency speech-to-speech | you tune it | managed | managed |
+
+## Requirements
+
+- Python **3.11+**
+- A ZRT runtime endpoint + auth token (from your Zero Runtime account)
+- API key(s) for the providers you use (e.g. Deepgram, Google, Cartesia)
+
+## Install
+
+```bash
+pip install --pre zrt
+```
+
+> Public beta — `--pre` is required until the stable release.
+
+## Quickstart
+
+**1. Set your environment**
+
+```bash
+export ZRT_RUNTIME_ADDRESS=us1.rt.zeroruntime.ai:443   # your ZRT runtime
+export ZRT_AUTH_TOKEN=<your-token>
+
+export DEEPGRAM_API_KEY=<key>    # speech-to-text
+export GOOGLE_API_KEY=<key>      # the LLM (Gemini)
+export CARTESIA_API_KEY=<key>    # text-to-speech
+```
+
+**2. Write your agent** — `agent.py`
+
+```python
+from zrt.agents import (
+    Agent, AgentSession, Pipeline, WorkerJob, JobContext, RoomOptions,
+    EOUConfig, InterruptConfig,
+)
+from zrt.plugins.deepgram import DeepgramSTT
+from zrt.plugins.google import GoogleLLM
+from zrt.plugins.cartesia import CartesiaTTS
+from zrt.plugins.silero import SileroVAD
+from zrt.plugins.turn_detector import NamoTurnDetectorV1
+from zrt.plugins.rnnoise import RNNoise
+
+IGNORE_PATTERNS = [r"\b(uh+|um+)\b"]   # filler words to drop from transcripts
+
+
+class Assistant(Agent):
+    def __init__(self):
+        super().__init__(instructions="You are a friendly voice assistant. Keep replies short.")
+
+    async def on_enter(self):
+        await self.session.say("Hi! How can I help?")
+
+    async def on_exit(self):
+        pass
+
+
+async def entrypoint(ctx: JobContext):
+    session = AgentSession(
+        agent=Assistant(),
+        pipeline=Pipeline(
+            stt=DeepgramSTT(),
+            llm=GoogleLLM(
+                model="gemini-2.5-flash",
+                thinking_budget=0,
+                include_thoughts=False,
+                max_output_tokens=8192,
+            ),
+            tts=CartesiaTTS(),
+            vad=SileroVAD(threshold=0.4),
+            turn_detector=NamoTurnDetectorV1(language="en", threshold=0.8),
+            denoise=RNNoise(),
+            eou_config=EOUConfig(mode="ADAPTIVE", min_max_speech_wait_timeout=[0.1, 0.3]),
+            interrupt_config=InterruptConfig(
+                interrupt_min_duration=0.5,
+                interrupt_min_words=2,
+                resume_on_false_interrupt=True,
+            ),
+            stt_filter_patterns=IGNORE_PATTERNS,
+            stt_word_substitutions={"recording": "", "recorded": ""},
+        ),
+    )
+    await session.start(wait_for_participant=True, run_until_shutdown=True)
+
+
+if __name__ == "__main__":
+    WorkerJob(
+        entrypoint=entrypoint,
+        jobctx=lambda: JobContext(room_options=RoomOptions(name="Assistant")),
+    ).start()
+```
+
+**3. Run it**
+
+```bash
+python agent.py
+```
+
+That's it — speech in → your agent → speech out, in real time.
+
+## How it works
+
+| Piece | What it is |
+|---|---|
+| **`Agent`** | Your behavior — instructions, tools, what it says on enter/exit. |
+| **`Pipeline`** | The voice stack: STT (hear) → LLM (think) → TTS (speak), plus VAD, turn detection, and denoising. |
+| **`WorkerJob`** | Runs your agent and connects it to Zero Runtime. |
+
+## Give your agent tools
+
+Let the LLM call your Python functions — just decorate them:
+
+```python
+from zrt.agents import function_tool
+
+@function_tool
+async def get_weather(city: str) -> dict:
+    """Get the weather for a city.
+
+    Args:
+        city: City name
+    """
+    return {"city": city, "temp_c": 22}
+
+# then pass them to your agent:
+#   super().__init__(instructions="...", tools=[get_weather])
+```
+
+Your tool runs in your worker; the runtime calls it when the LLM decides to.
+
+## Providers
+
+Mix and match — bring the best model for each stage, swap any one in a line:
+
+- **Speech-to-text (STT):** Deepgram, AssemblyAI, Google, Azure, Gladia, NVIDIA, Sarvam
+- **LLM:** OpenAI, Google Gemini, Anthropic Claude, Groq, Cerebras, xAI Grok, Sarvam
+- **Text-to-speech (TTS):** Cartesia, ElevenLabs, Google, AWS Polly, Azure, Deepgram, Rime, LMNT, Neuphonic, Hume AI, Inworld, Murf, Resemble, Smallest, Speechify, CambAI, NVIDIA
+- **Realtime speech-to-speech:** OpenAI Realtime, Gemini Live, Ultravox, Azure Voice Live
+- **Turn detection:** Namo · **VAD:** Silero · **Denoise:** RNNoise
+
+```python
+from zrt.plugins.elevenlabs import ElevenLabsTTS   # different TTS
+from zrt.plugins.anthropic import AnthropicLLM      # different LLM
+```
+
+## Use cases
+
+Phone & telephony agents, IVR replacement, customer-support voice bots, voice
+assistants, outbound/inbound call automation, and any real-time conversational AI.
+
+## FAQ
+
+**How is this different from a voice-agent framework?**
+* Frameworks make you host and scale the real-time runtime (media, GPUs, turn-taking).
+ZRT runs that for you — you only write and deploy the agent.
+
+**How is it different from a no-code voice platform?**
+* You write real Python with your own tools, logic, and providers — not a dashboard
+configuration. Full code control, zero infrastructure.
+
+**Can I use my own STT / LLM / TTS providers?**
+* Yes — mix any supported providers, and bring your own API keys.
+
+**What do I need to run it?**
+* A ZRT runtime endpoint + token and the provider keys for the stages you use.
+
+## Examples
+
+More complete examples: https://github.com/ZeroRuntimeAI/zrt-python-sdk-examples
+
+## Contact
+support@videosdk.live
+
+Copyright © 2026 Zujo Tech Pvt Ltd. All rights reserved.

zrt-0.0.1b1/README.md

@@ -0,0 +1,195 @@
+# ZRT — Zero Runtime Python SDK
+
+**Build real-time AI voice agents in Python — without running the infrastructure.**
+You write the agent (instructions, tools, logic); **Zero Runtime** runs the live
+speech-to-speech pipeline — speech-to-text → LLM → text-to-speech, with turn
+detection, denoising, and interruptions — at low latency in the cloud.
+
+> **Write the agent. We run the runtime.**
+
+## A different kind of voice SDK
+
+Most voice frameworks make you run the hard part — media servers, GPUs, turn-taking,
+autoscaling. No-code platforms hide all that but lock you into a dashboard.
+**Zero Runtime is the middle:** real Python and your own providers, with none of the
+real-time infrastructure to operate.
+
+| | Self-hosted frameworks | No-code platforms | **Zero Runtime** |
+|---|:---:|:---:|:---:|
+| Write real Python + custom tools | ✅ | ❌ (dashboard) | ✅ |
+| Run media servers / GPUs / scaling | ❌ *you run it* | ✅ managed | ✅ managed |
+| Swap any STT / LLM / TTS provider | ✅ | limited | ✅ |
+| Low-latency speech-to-speech | you tune it | managed | managed |
+
+## Requirements
+
+- Python **3.11+**
+- A ZRT runtime endpoint + auth token (from your Zero Runtime account)
+- API key(s) for the providers you use (e.g. Deepgram, Google, Cartesia)
+
+## Install
+
+```bash
+pip install --pre zrt
+```
+
+> Public beta — `--pre` is required until the stable release.
+
+## Quickstart
+
+**1. Set your environment**
+
+```bash
+export ZRT_RUNTIME_ADDRESS=us1.rt.zeroruntime.ai:443   # your ZRT runtime
+export ZRT_AUTH_TOKEN=<your-token>
+
+export DEEPGRAM_API_KEY=<key>    # speech-to-text
+export GOOGLE_API_KEY=<key>      # the LLM (Gemini)
+export CARTESIA_API_KEY=<key>    # text-to-speech
+```
+
+**2. Write your agent** — `agent.py`
+
+```python
+from zrt.agents import (
+    Agent, AgentSession, Pipeline, WorkerJob, JobContext, RoomOptions,
+    EOUConfig, InterruptConfig,
+)
+from zrt.plugins.deepgram import DeepgramSTT
+from zrt.plugins.google import GoogleLLM
+from zrt.plugins.cartesia import CartesiaTTS
+from zrt.plugins.silero import SileroVAD
+from zrt.plugins.turn_detector import NamoTurnDetectorV1
+from zrt.plugins.rnnoise import RNNoise
+
+IGNORE_PATTERNS = [r"\b(uh+|um+)\b"]   # filler words to drop from transcripts
+
+
+class Assistant(Agent):
+    def __init__(self):
+        super().__init__(instructions="You are a friendly voice assistant. Keep replies short.")
+
+    async def on_enter(self):
+        await self.session.say("Hi! How can I help?")
+
+    async def on_exit(self):
+        pass
+
+
+async def entrypoint(ctx: JobContext):
+    session = AgentSession(
+        agent=Assistant(),
+        pipeline=Pipeline(
+            stt=DeepgramSTT(),
+            llm=GoogleLLM(
+                model="gemini-2.5-flash",
+                thinking_budget=0,
+                include_thoughts=False,
+                max_output_tokens=8192,
+            ),
+            tts=CartesiaTTS(),
+            vad=SileroVAD(threshold=0.4),
+            turn_detector=NamoTurnDetectorV1(language="en", threshold=0.8),
+            denoise=RNNoise(),
+            eou_config=EOUConfig(mode="ADAPTIVE", min_max_speech_wait_timeout=[0.1, 0.3]),
+            interrupt_config=InterruptConfig(
+                interrupt_min_duration=0.5,
+                interrupt_min_words=2,
+                resume_on_false_interrupt=True,
+            ),
+            stt_filter_patterns=IGNORE_PATTERNS,
+            stt_word_substitutions={"recording": "", "recorded": ""},
+        ),
+    )
+    await session.start(wait_for_participant=True, run_until_shutdown=True)
+
+
+if __name__ == "__main__":
+    WorkerJob(
+        entrypoint=entrypoint,
+        jobctx=lambda: JobContext(room_options=RoomOptions(name="Assistant")),
+    ).start()
+```
+
+**3. Run it**
+
+```bash
+python agent.py
+```
+
+That's it — speech in → your agent → speech out, in real time.
+
+## How it works
+
+| Piece | What it is |
+|---|---|
+| **`Agent`** | Your behavior — instructions, tools, what it says on enter/exit. |
+| **`Pipeline`** | The voice stack: STT (hear) → LLM (think) → TTS (speak), plus VAD, turn detection, and denoising. |
+| **`WorkerJob`** | Runs your agent and connects it to Zero Runtime. |
+
+## Give your agent tools
+
+Let the LLM call your Python functions — just decorate them:
+
+```python
+from zrt.agents import function_tool
+
+@function_tool
+async def get_weather(city: str) -> dict:
+    """Get the weather for a city.
+
+    Args:
+        city: City name
+    """
+    return {"city": city, "temp_c": 22}
+
+# then pass them to your agent:
+#   super().__init__(instructions="...", tools=[get_weather])
+```
+
+Your tool runs in your worker; the runtime calls it when the LLM decides to.
+
+## Providers
+
+Mix and match — bring the best model for each stage, swap any one in a line:
+
+- **Speech-to-text (STT):** Deepgram, AssemblyAI, Google, Azure, Gladia, NVIDIA, Sarvam
+- **LLM:** OpenAI, Google Gemini, Anthropic Claude, Groq, Cerebras, xAI Grok, Sarvam
+- **Text-to-speech (TTS):** Cartesia, ElevenLabs, Google, AWS Polly, Azure, Deepgram, Rime, LMNT, Neuphonic, Hume AI, Inworld, Murf, Resemble, Smallest, Speechify, CambAI, NVIDIA
+- **Realtime speech-to-speech:** OpenAI Realtime, Gemini Live, Ultravox, Azure Voice Live
+- **Turn detection:** Namo · **VAD:** Silero · **Denoise:** RNNoise
+
+```python
+from zrt.plugins.elevenlabs import ElevenLabsTTS   # different TTS
+from zrt.plugins.anthropic import AnthropicLLM      # different LLM
+```
+
+## Use cases
+
+Phone & telephony agents, IVR replacement, customer-support voice bots, voice
+assistants, outbound/inbound call automation, and any real-time conversational AI.
+
+## FAQ
+
+**How is this different from a voice-agent framework?**
+* Frameworks make you host and scale the real-time runtime (media, GPUs, turn-taking).
+ZRT runs that for you — you only write and deploy the agent.
+
+**How is it different from a no-code voice platform?**
+* You write real Python with your own tools, logic, and providers — not a dashboard
+configuration. Full code control, zero infrastructure.
+
+**Can I use my own STT / LLM / TTS providers?**
+* Yes — mix any supported providers, and bring your own API keys.
+
+**What do I need to run it?**
+* A ZRT runtime endpoint + token and the provider keys for the stages you use.
+
+## Examples
+
+More complete examples: https://github.com/ZeroRuntimeAI/zrt-python-sdk-examples
+
+## Contact
+support@videosdk.live
+
+Copyright © 2026 Zujo Tech Pvt Ltd. All rights reserved.

zrt-0.0.1b1/pyproject.toml

@@ -0,0 +1,83 @@
+[build-system]
+requires = ["setuptools>=77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zrt"
+dynamic = ["version"]
+description = "Build real-time AI voice agents in Python. Zero Runtime runs the speech-to-speech pipeline (STT, LLM, TTS) for you."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+authors = [{ name = "Zujo Tech Pvt Ltd", email = "support@videosdk.live" }]
+keywords = [
+    "voice-agents", "voice-ai", "ai-voice-agent", "conversational-ai",
+    "voice-assistant", "speech-to-speech", "realtime-voice", "voicebot",
+    "llm", "stt", "tts", "speech-to-text", "text-to-speech",
+    "telephony", "sip", "webrtc", "zero-runtime",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "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 :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    # gRPC transport to the runtime + async HTTP for auth/init. Floors have 3.14 wheels.
+    "grpcio>=1.81.0",
+    "protobuf>=6.31.0",
+    "aiohttp>=3.9.0",
+]
+
+[project.optional-dependencies]
+# Vision helper — only when passing frame objects (PIL.Image / numpy / av) to
+# session.send_image() / send_message_with_frames(). Pre-encoded bytes never need it.
+vision = ["Pillow>=10.0"]
+dev = [
+    "pytest>=8.4",
+    "pytest-asyncio>=0.24",
+    "grpcio-tools>=1.81.0",
+    "build>=1.2",
+    "twine>=6.0",
+    "ruff>=0.6",
+]
+
+[project.urls]
+Homepage = "https://zeroruntime.ai/"
+Examples = "https://github.com/ZeroRuntimeAI/zrt-python-sdk-examples"
+
+[tool.setuptools.packages.find]
+include = ["zrt*"]
+
+[tool.setuptools.package-data]
+zrt = ["py.typed"]
+
+[tool.setuptools.dynamic]
+version = { attr = "zrt.__version__" }
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+# Generated protobuf stubs + the vendored runtime SDK package are not linted.
+extend-exclude = ["*_pb2.py", "*_pb2_grpc.py", "zrt/agents", "zrt/plugins"]
+
+[tool.ruff.lint.per-file-ignores]
+# Aggregator packages re-export names and import after a setup function.
+"__init__.py" = ["E402", "F401"]
+# importorskip() must run before importing modules that need the optional dep.
+"tests/test_grpc_loopback.py" = ["E402"]
+"tests/test_grpc_headers.py" = ["E402"]

zrt-0.0.1b1/setup.cfg

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

zrt-0.0.1b1/tests/test_grpc_headers.py

@@ -0,0 +1,66 @@
+"""The SDK must attach the minimal identity headers to every gRPC call."""
+import pytest
+
+grpc = pytest.importorskip("grpc")
+pytest.importorskip("zrt.agents.agent_runtime_pb2")
+
+from zrt.agents import agent_runtime_pb2 as pb
+from zrt.agents import agent_runtime_pb2_grpc as pbg
+from zrt.agents._grpc_bridge import _open_grpc_channel
+
+
+class _Servicer(pbg.AgentRuntimeServicer):
+    def __init__(self):
+        self.metadata = {}
+
+    async def CreateSession(self, request, context):
+        self.metadata = dict(context.invocation_metadata())
+        return pb.CreateSessionResponse(
+            session=pb.SessionInfo(session_id="s1", runtime_version="rt/1"))
+
+
+async def test_minimal_headers_sent(monkeypatch):
+    monkeypatch.setenv("ZRT_RUNTIME_INSECURE", "1")
+
+    servicer = _Servicer()
+    server = grpc.aio.server()
+    pbg.add_AgentRuntimeServicer_to_server(servicer, server)
+    port = server.add_insecure_port("127.0.0.1:0")
+    await server.start()
+    try:
+        ch = _open_grpc_channel(f"127.0.0.1:{port}", auth_token="room-jwt-xyz")
+        stub = pbg.AgentRuntimeStub(ch)
+        await stub.CreateSession(pb.SessionConfig(session_id="s1"))
+        await ch.close()
+    finally:
+        await server.stop(0)
+
+    md = servicer.metadata
+    assert md["x-zrt-sdk"] == "zrt-python"
+    assert md["x-zrt-sdk-version"]
+    assert md["x-zrt-proto-version"] == "1"
+    assert md["x-zrt-device-os"]
+    assert md["x-zrt-device-arch"]
+    assert md["x-zrt-host"]
+    assert md["authorization"] == "Bearer room-jwt-xyz"
+
+
+async def test_auth_header_omitted_without_token(monkeypatch):
+    monkeypatch.setenv("ZRT_RUNTIME_INSECURE", "1")
+    monkeypatch.delenv("ZRT_AUTH_TOKEN", raising=False)
+
+    servicer = _Servicer()
+    server = grpc.aio.server()
+    pbg.add_AgentRuntimeServicer_to_server(servicer, server)
+    port = server.add_insecure_port("127.0.0.1:0")
+    await server.start()
+    try:
+        ch = _open_grpc_channel(f"127.0.0.1:{port}")  # no token
+        stub = pbg.AgentRuntimeStub(ch)
+        await stub.CreateSession(pb.SessionConfig(session_id="s1"))
+        await ch.close()
+    finally:
+        await server.stop(0)
+
+    assert "authorization" not in servicer.metadata
+    assert servicer.metadata["x-zrt-sdk"] == "zrt-python"

zrt-0.0.1b1/tests/test_imports.py

@@ -0,0 +1,23 @@
+"""Every submodule (agents core + all provider plugins) must import cleanly."""
+import importlib
+import pkgutil
+
+
+def test_all_submodules_import():
+    import zrt.agents
+    import zrt.plugins
+
+    failures = []
+    for pkg in (zrt.agents, zrt.plugins):
+        for mod in pkgutil.walk_packages(pkg.__path__, pkg.__name__ + "."):
+            try:
+                importlib.import_module(mod.name)
+            except Exception as exc:  # noqa: BLE001
+                failures.append(f"{mod.name}: {type(exc).__name__}: {exc}")
+    assert not failures, "import failures:\n" + "\n".join(failures)
+
+
+def test_version():
+    import zrt
+
+    assert isinstance(zrt.__version__, str) and zrt.__version__.count(".") >= 1