zizkadb-livekit 0.1.0__tar.gz

zizkadb_livekit-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: zizkadb-livekit
+Version: 0.1.0
+Summary: LiveKit Agents observer for ZizkaDB — one session per call, transcript from LiveKit (no audio stored)
+License-Expression: AGPL-3.0-or-later
+Project-URL: Repository, https://github.com/Zizka-ai/ZizkaDB
+Project-URL: Documentation, https://db.zizka.ai/docs
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: zizkadb-sdk>=0.2.7
+Requires-Dist: livekit-agents>=1.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# ZizkaDB + LiveKit Agents
+
+**PyPI:** [zizkadb-livekit 0.1.0](https://pypi.org/project/zizkadb-livekit/) · depends on `zizkadb-sdk>=0.2.7` + `livekit-agents>=1.3.0`
+
+Log voice calls to ZizkaDB with the same **Activity → Sessions / Events** model as text agents.
+
+- **One `session_id` per call** (use LiveKit room name or job id)
+- **Transcript only** — text copied from LiveKit `make_session_report()` (no audio in ZizkaDB)
+- **Backend events** — `tool_call`, `tool_result`, `error`, pipeline events from the report
+- **Causal lineage** — `parent_id` chains for Why? in the dashboard
+
+## Install
+
+```bash
+pip install "zizkadb-livekit>=0.1.0"
+```
+
+Start ZizkaDB (Docker quickstart):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Zizka-ai/ZizkaDB/main/scripts/quickstart-remote.sh | bash
+```
+
+## Usage
+
+```python
+import os
+from livekit.agents import AgentServer, JobContext, AgentSession, Agent
+from zizkadb import ZizkaDB
+from zizkadb_livekit import ZizkaDBLiveKitObserver
+
+server = AgentServer()
+
+async def on_session_end(ctx: JobContext) -> None:
+    await observer.ingest_session_report(ctx)
+
+@server.rtc_session(agent_name="support-voice", on_session_end=on_session_end)
+async def entrypoint(ctx: JobContext):
+    await ctx.connect()
+
+    db = ZizkaDB(host=os.getenv("ZIZKADB_HOST", "http://localhost:8000"))
+    global observer
+    observer = ZizkaDBLiveKitObserver(
+        db,
+        agent=os.getenv("ZIZKADB_AGENT", "support-voice"),
+        session_id=f"call_{ctx.room.name}",
+    )
+    await observer.log_session_started(room=ctx.room.name, job_id=ctx.job.id)
+
+    session = AgentSession(...)
+    observer.attach(session, job_ctx=ctx)  # optional realtime turns
+
+    await session.start(agent=Agent(instructions="..."), room=ctx.room)
+```
+
+Open **http://localhost:3001** → Activity → your agent → Sessions.
+
+## Event types
+
+| Event | Source |
+|-------|--------|
+| `session_started` | Call connect |
+| `user_message` | LiveKit user transcript |
+| `assistant_response` | LiveKit agent transcript |
+| `tool_call` / `tool_result` | Tools + report pipeline events |
+| `error` | Failures |
+| `session_ended` | Post-call ingest |
+
+Manual helpers: `log_tool_call`, `log_tool_result`, `log_error`.
+
+## Environment
+
+```bash
+export ZIZKADB_HOST=http://localhost:8000   # self-host
+export ZIZKADB_AGENT=support-voice
+# Cloud: export ZIZKADB_API_KEY=zizkadb_live_...
+```
+
+See [examples/livekit-agent](../../examples/livekit-agent/) for a full sample.

zizkadb_livekit-0.1.0/README.md

@@ -0,0 +1,79 @@
+# ZizkaDB + LiveKit Agents
+
+**PyPI:** [zizkadb-livekit 0.1.0](https://pypi.org/project/zizkadb-livekit/) · depends on `zizkadb-sdk>=0.2.7` + `livekit-agents>=1.3.0`
+
+Log voice calls to ZizkaDB with the same **Activity → Sessions / Events** model as text agents.
+
+- **One `session_id` per call** (use LiveKit room name or job id)
+- **Transcript only** — text copied from LiveKit `make_session_report()` (no audio in ZizkaDB)
+- **Backend events** — `tool_call`, `tool_result`, `error`, pipeline events from the report
+- **Causal lineage** — `parent_id` chains for Why? in the dashboard
+
+## Install
+
+```bash
+pip install "zizkadb-livekit>=0.1.0"
+```
+
+Start ZizkaDB (Docker quickstart):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Zizka-ai/ZizkaDB/main/scripts/quickstart-remote.sh | bash
+```
+
+## Usage
+
+```python
+import os
+from livekit.agents import AgentServer, JobContext, AgentSession, Agent
+from zizkadb import ZizkaDB
+from zizkadb_livekit import ZizkaDBLiveKitObserver
+
+server = AgentServer()
+
+async def on_session_end(ctx: JobContext) -> None:
+    await observer.ingest_session_report(ctx)
+
+@server.rtc_session(agent_name="support-voice", on_session_end=on_session_end)
+async def entrypoint(ctx: JobContext):
+    await ctx.connect()
+
+    db = ZizkaDB(host=os.getenv("ZIZKADB_HOST", "http://localhost:8000"))
+    global observer
+    observer = ZizkaDBLiveKitObserver(
+        db,
+        agent=os.getenv("ZIZKADB_AGENT", "support-voice"),
+        session_id=f"call_{ctx.room.name}",
+    )
+    await observer.log_session_started(room=ctx.room.name, job_id=ctx.job.id)
+
+    session = AgentSession(...)
+    observer.attach(session, job_ctx=ctx)  # optional realtime turns
+
+    await session.start(agent=Agent(instructions="..."), room=ctx.room)
+```
+
+Open **http://localhost:3001** → Activity → your agent → Sessions.
+
+## Event types
+
+| Event | Source |
+|-------|--------|
+| `session_started` | Call connect |
+| `user_message` | LiveKit user transcript |
+| `assistant_response` | LiveKit agent transcript |
+| `tool_call` / `tool_result` | Tools + report pipeline events |
+| `error` | Failures |
+| `session_ended` | Post-call ingest |
+
+Manual helpers: `log_tool_call`, `log_tool_result`, `log_error`.
+
+## Environment
+
+```bash
+export ZIZKADB_HOST=http://localhost:8000   # self-host
+export ZIZKADB_AGENT=support-voice
+# Cloud: export ZIZKADB_API_KEY=zizkadb_live_...
+```
+
+See [examples/livekit-agent](../../examples/livekit-agent/) for a full sample.

zizkadb_livekit-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zizkadb-livekit"
+version = "0.1.0"
+description = "LiveKit Agents observer for ZizkaDB — one session per call, transcript from LiveKit (no audio stored)"
+readme = "README.md"
+license = "AGPL-3.0-or-later"
+requires-python = ">=3.10"
+dependencies = [
+    "zizkadb-sdk>=0.2.7",
+    "livekit-agents>=1.3.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[project.urls]
+Repository = "https://github.com/Zizka-ai/ZizkaDB"
+Documentation = "https://db.zizka.ai/docs"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["zizkadb_livekit*"]

zizkadb_livekit-0.1.0/setup.cfg

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

zizkadb_livekit-0.1.0/zizkadb_livekit/__init__.py

@@ -0,0 +1,7 @@
+from zizkadb.telemetry import ping_on_install
+
+from .observer import ZizkaDBLiveKitObserver
+
+ping_on_install(sdk="livekit")
+
+__all__ = ["ZizkaDBLiveKitObserver"]

zizkadb_livekit-0.1.0/zizkadb_livekit/_report.py

@@ -0,0 +1,103 @@
+"""Parse LiveKit SessionReport dicts for ZizkaDB event ingest."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def normalize_report(report: dict[str, Any]) -> dict[str, Any]:
+    """Accept make_session_report().to_dict() or an equivalent structure."""
+    if not isinstance(report, dict):
+        raise TypeError("report must be a dict from SessionReport.to_dict()")
+    return report
+
+
+def chat_items(report: dict[str, Any]) -> list[dict[str, Any]]:
+    history = report.get("chat_history") or {}
+    if isinstance(history, list):
+        items = history
+    elif isinstance(history, dict):
+        items = history.get("items") or []
+    else:
+        items = []
+    out: list[dict[str, Any]] = []
+    for raw in items:
+        if not isinstance(raw, dict):
+            continue
+        item = dict(raw)
+        item_id = item.get("id") or item.get("item_id")
+        if item_id is not None:
+            item["id"] = str(item_id)
+        out.append(item)
+    out.sort(key=_sort_key)
+    return out
+
+
+def backend_events(report: dict[str, Any]) -> list[dict[str, Any]]:
+    """Non-transcript pipeline events from the session report."""
+    rows: list[dict[str, Any]] = []
+    for raw in report.get("events") or []:
+        if not isinstance(raw, dict):
+            continue
+        if raw.get("type") == "metrics_collected":
+            continue
+        rows.append(dict(raw))
+    rows.sort(key=_sort_key)
+    return rows
+
+
+def item_text(item: dict[str, Any]) -> str:
+    content = item.get("content")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict):
+                text = part.get("text") or part.get("content")
+                if text:
+                    parts.append(str(text))
+        return "\n".join(parts)
+    if content is not None:
+        return str(content)
+    return ""
+
+
+def item_role(item: dict[str, Any]) -> str:
+    role = (item.get("role") or item.get("speaker") or "unknown").lower()
+    if role in ("assistant", "agent"):
+        return "assistant"
+    if role in ("user", "human"):
+        return "user"
+    return role
+
+
+def zizka_event_for_role(role: str) -> str | None:
+    if role == "user":
+        return "user_message"
+    if role == "assistant":
+        return "assistant_response"
+    return None
+
+
+def zizka_event_for_report_event(ev: dict[str, Any]) -> str:
+    et = (ev.get("type") or ev.get("event") or "livekit_event").lower()
+    if "tool" in et and "result" in et:
+        return "tool_result"
+    if "tool" in et or "function" in et:
+        return "tool_call"
+    if "error" in et or "fail" in et:
+        return "error"
+    if "api" in et or "http" in et:
+        return "api_call"
+    return "livekit_event"
+
+
+def _sort_key(row: dict[str, Any]) -> float:
+    for key in ("created_at", "timestamp", "started_at"):
+        val = row.get(key)
+        if isinstance(val, (int, float)):
+            return float(val)
+    return 0.0

zizkadb_livekit-0.1.0/zizkadb_livekit/observer.py

@@ -0,0 +1,315 @@
+"""
+LiveKit Agents → ZizkaDB observer.
+
+Maps each voice call to one ZizkaDB session (session_id) and logs transcript
+turns plus backend events. Transcript text is copied from LiveKit's session
+report — ZizkaDB does not record or store audio.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable
+
+from zizkadb import ZizkaDB
+from zizkadb.models import LogResult
+
+from ._report import (
+    backend_events,
+    chat_items,
+    item_role,
+    item_text,
+    normalize_report,
+    zizka_event_for_report_event,
+    zizka_event_for_role,
+)
+
+log = logging.getLogger(__name__)
+
+SessionIdFactory = Callable[[Any], str]
+
+
+class ZizkaDBLiveKitObserver:
+    """
+    Log LiveKit voice calls to ZizkaDB using the same Activity model as text agents:
+    one session_id per call, transcript as user_message / assistant_response events.
+
+    Usage:
+        db = ZizkaDB(host="http://localhost:8000")
+        observer = ZizkaDBLiveKitObserver(db, agent="voice-support", session_id=ctx.room.name)
+        await observer.log_session_started(room=ctx.room.name, job_id=ctx.job.id)
+        observer.attach(session)  # optional realtime turns
+        # in on_session_end:
+        await observer.ingest_session_report(ctx)
+    """
+
+    def __init__(
+        self,
+        db: ZizkaDB,
+        agent: str,
+        session_id: str,
+        *,
+        session_id_from: SessionIdFactory | None = None,
+    ) -> None:
+        self.db = db
+        self.agent = agent
+        self.session_id = session_id
+        self.session_id_from = session_id_from
+        self.last_event_id: str | None = None
+        self._seen_item_ids: set[str] = set()
+        self._session_started = False
+        self._session_ended = False
+        self._realtime_attached = False
+        self._last_result: LogResult | None = None
+        self._report_ingested = False
+
+    async def log_session_started(
+        self,
+        *,
+        room: str | None = None,
+        job_id: str | None = None,
+        **extra: Any,
+    ) -> LogResult:
+        if self._session_started:
+            assert self._last_result is not None
+            return self._last_result
+        data: dict[str, Any] = {"source": "livekit", **extra}
+        if room is not None:
+            data["room"] = room
+        if job_id is not None:
+            data["job_id"] = job_id
+        result = await self._log(
+            event="session_started",
+            data=data,
+            parent_id=None,
+        )
+        self._session_started = True
+        return result
+
+    async def log_session_ended(
+        self,
+        *,
+        turn_count: int | None = None,
+        duration_s: float | None = None,
+        livekit_job_id: str | None = None,
+        **extra: Any,
+    ) -> LogResult:
+        data: dict[str, Any] = {"source": "livekit", **extra}
+        if turn_count is not None:
+            data["turn_count"] = turn_count
+        if duration_s is not None:
+            data["duration_s"] = duration_s
+        if livekit_job_id is not None:
+            data["livekit_job_id"] = livekit_job_id
+        result = await self._log(
+            event="session_ended",
+            data=data,
+            parent_id=self.last_event_id,
+        )
+        self._session_ended = True
+        return result
+
+    def attach(self, session: Any, job_ctx: Any | None = None) -> None:
+        if self._realtime_attached:
+            return
+
+        if job_ctx is not None and self.session_id_from is not None:
+            self.session_id = self.session_id_from(job_ctx)
+
+        def on_conversation_item_added(ev: Any) -> None:
+            try:
+                import asyncio
+
+                asyncio.get_running_loop().create_task(self._on_conversation_item(ev))
+            except RuntimeError:
+                log.debug("conversation_item_added outside running loop; skipped")
+
+        if hasattr(session, "on"):
+            session.on("conversation_item_added", on_conversation_item_added)
+        self._realtime_attached = True
+
+    async def ingest_session_report(self, ctx: Any) -> list[LogResult]:
+        make_report = getattr(ctx, "make_session_report", None)
+        if make_report is None:
+            raise TypeError("ctx must provide make_session_report() (LiveKit JobContext)")
+        report = make_report()
+        to_dict = getattr(report, "to_dict", None)
+        if to_dict is None:
+            raise TypeError("SessionReport must provide to_dict()")
+        return await self.ingest_report(to_dict())
+
+    async def ingest_report(self, report: dict[str, Any]) -> list[LogResult]:
+        report = normalize_report(report)
+        results: list[LogResult] = []
+        backfill_only = self._report_ingested
+
+        if not self._session_started:
+            results.append(
+                await self.log_session_started(
+                    room=report.get("room"),
+                    job_id=report.get("job_id"),
+                    room_id=report.get("room_id"),
+                )
+            )
+
+        for item in chat_items(report):
+            item_id = item.get("id")
+            if item_id and item_id in self._seen_item_ids:
+                continue
+            role = item_role(item)
+            event_type = zizka_event_for_role(role)
+            if event_type is None:
+                continue
+            text = item_text(item)
+            if not text.strip():
+                continue
+            data: dict[str, Any] = {"content": text}
+            if item.get("interrupted") is not None:
+                data["interrupted"] = item["interrupted"]
+            if item.get("created_at") is not None:
+                data["created_at"] = item["created_at"]
+            metadata = {"source": "livekit"}
+            if item_id:
+                metadata["livekit_item_id"] = item_id
+            results.append(
+                await self._log(
+                    event=event_type,
+                    data=data,
+                    parent_id=self.last_event_id,
+                    metadata=metadata,
+                )
+            )
+            if item_id:
+                self._seen_item_ids.add(item_id)
+
+        if not backfill_only:
+            for ev in backend_events(report):
+                event_type = zizka_event_for_report_event(ev)
+                ev_type = ev.get("type") or ev.get("event")
+                data = {k: v for k, v in ev.items() if k not in ("type", "event")}
+                if ev_type:
+                    data["livekit_type"] = ev_type
+                results.append(
+                    await self._log(
+                        event=event_type,
+                        data=data,
+                        parent_id=self.last_event_id,
+                        metadata={"source": "livekit", "livekit_event": True},
+                    )
+                )
+
+            if not self._session_ended:
+                results.append(
+                    await self.log_session_ended(
+                        turn_count=len(chat_items(report)),
+                        livekit_job_id=report.get("job_id"),
+                    )
+                )
+
+            self._report_ingested = True
+
+        return results
+
+    async def log_tool_call(
+        self,
+        tool: str,
+        *,
+        args: dict[str, Any] | None = None,
+        parent_id: str | None = None,
+        **extra: Any,
+    ) -> LogResult:
+        data: dict[str, Any] = {"tool": tool, **extra}
+        if args is not None:
+            data["args"] = args
+        return await self._log(
+            event="tool_call",
+            data=data,
+            parent_id=parent_id or self.last_event_id,
+        )
+
+    async def log_tool_result(
+        self,
+        tool: str,
+        *,
+        output: Any = None,
+        parent_id: str | None = None,
+        **extra: Any,
+    ) -> LogResult:
+        data: dict[str, Any] = {"tool": tool, **extra}
+        if output is not None:
+            data["output"] = output
+        return await self._log(
+            event="tool_result",
+            data=data,
+            parent_id=parent_id or self.last_event_id,
+        )
+
+    async def log_error(
+        self,
+        message: str,
+        *,
+        stage: str | None = None,
+        parent_id: str | None = None,
+        **extra: Any,
+    ) -> LogResult:
+        data: dict[str, Any] = {"error": message, **extra}
+        if stage is not None:
+            data["stage"] = stage
+        return await self._log(
+            event="error",
+            data=data,
+            parent_id=parent_id or self.last_event_id,
+        )
+
+    async def _on_conversation_item(self, ev: Any) -> None:
+        item = getattr(ev, "item", None)
+        if item is None:
+            return
+        item_id = getattr(item, "id", None) or getattr(item, "item_id", None)
+        if item_id is not None:
+            item_id = str(item_id)
+            if item_id in self._seen_item_ids:
+                return
+        role = item_role(
+            {
+                "role": getattr(item, "role", None),
+                "content": getattr(item, "content", None),
+            }
+        )
+        event_type = zizka_event_for_role(role)
+        if event_type is None:
+            return
+        text = item_text({"content": getattr(item, "content", "")})
+        if not text.strip():
+            return
+        metadata = {"source": "livekit", "realtime": True}
+        if item_id:
+            metadata["livekit_item_id"] = item_id
+        await self._log(
+            event=event_type,
+            data={"content": text},
+            parent_id=self.last_event_id,
+            metadata=metadata,
+        )
+        if item_id:
+            self._seen_item_ids.add(item_id)
+
+    async def _log(
+        self,
+        *,
+        event: str,
+        data: dict[str, Any],
+        parent_id: str | None,
+        metadata: dict[str, Any] | None = None,
+    ) -> LogResult:
+        result = await self.db.log(
+            agent=self.agent,
+            event=event,
+            data=data,
+            parent_id=parent_id,
+            session_id=self.session_id,
+            metadata=metadata,
+        )
+        self.last_event_id = result.event_id
+        self._last_result = result
+        return result

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

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: zizkadb-livekit
+Version: 0.1.0
+Summary: LiveKit Agents observer for ZizkaDB — one session per call, transcript from LiveKit (no audio stored)
+License-Expression: AGPL-3.0-or-later
+Project-URL: Repository, https://github.com/Zizka-ai/ZizkaDB
+Project-URL: Documentation, https://db.zizka.ai/docs
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: zizkadb-sdk>=0.2.7
+Requires-Dist: livekit-agents>=1.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# ZizkaDB + LiveKit Agents
+
+**PyPI:** [zizkadb-livekit 0.1.0](https://pypi.org/project/zizkadb-livekit/) · depends on `zizkadb-sdk>=0.2.7` + `livekit-agents>=1.3.0`
+
+Log voice calls to ZizkaDB with the same **Activity → Sessions / Events** model as text agents.
+
+- **One `session_id` per call** (use LiveKit room name or job id)
+- **Transcript only** — text copied from LiveKit `make_session_report()` (no audio in ZizkaDB)
+- **Backend events** — `tool_call`, `tool_result`, `error`, pipeline events from the report
+- **Causal lineage** — `parent_id` chains for Why? in the dashboard
+
+## Install
+
+```bash
+pip install "zizkadb-livekit>=0.1.0"
+```
+
+Start ZizkaDB (Docker quickstart):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Zizka-ai/ZizkaDB/main/scripts/quickstart-remote.sh | bash
+```
+
+## Usage
+
+```python
+import os
+from livekit.agents import AgentServer, JobContext, AgentSession, Agent
+from zizkadb import ZizkaDB
+from zizkadb_livekit import ZizkaDBLiveKitObserver
+
+server = AgentServer()
+
+async def on_session_end(ctx: JobContext) -> None:
+    await observer.ingest_session_report(ctx)
+
+@server.rtc_session(agent_name="support-voice", on_session_end=on_session_end)
+async def entrypoint(ctx: JobContext):
+    await ctx.connect()
+
+    db = ZizkaDB(host=os.getenv("ZIZKADB_HOST", "http://localhost:8000"))
+    global observer
+    observer = ZizkaDBLiveKitObserver(
+        db,
+        agent=os.getenv("ZIZKADB_AGENT", "support-voice"),
+        session_id=f"call_{ctx.room.name}",
+    )
+    await observer.log_session_started(room=ctx.room.name, job_id=ctx.job.id)
+
+    session = AgentSession(...)
+    observer.attach(session, job_ctx=ctx)  # optional realtime turns
+
+    await session.start(agent=Agent(instructions="..."), room=ctx.room)
+```
+
+Open **http://localhost:3001** → Activity → your agent → Sessions.
+
+## Event types
+
+| Event | Source |
+|-------|--------|
+| `session_started` | Call connect |
+| `user_message` | LiveKit user transcript |
+| `assistant_response` | LiveKit agent transcript |
+| `tool_call` / `tool_result` | Tools + report pipeline events |
+| `error` | Failures |
+| `session_ended` | Post-call ingest |
+
+Manual helpers: `log_tool_call`, `log_tool_result`, `log_error`.
+
+## Environment
+
+```bash
+export ZIZKADB_HOST=http://localhost:8000   # self-host
+export ZIZKADB_AGENT=support-voice
+# Cloud: export ZIZKADB_API_KEY=zizkadb_live_...
+```
+
+See [examples/livekit-agent](../../examples/livekit-agent/) for a full sample.

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+zizkadb_livekit/__init__.py
+zizkadb_livekit/_report.py
+zizkadb_livekit/observer.py
+zizkadb_livekit.egg-info/PKG-INFO
+zizkadb_livekit.egg-info/SOURCES.txt
+zizkadb_livekit.egg-info/dependency_links.txt
+zizkadb_livekit.egg-info/requires.txt
+zizkadb_livekit.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,6 @@
+zizkadb-sdk>=0.2.7
+livekit-agents>=1.3.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23

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

@@ -0,0 +1 @@
+zizkadb_livekit