feat(examples): publish examples manifest to agents-jukebox

.github/workflows/deploy-examples.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        example: [healthcare, survey, frontdesk, drive-thru]
+        example: [healthcare, survey, frontdesk, drive-thru, inference]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
@@ -47,12 +47,36 @@ jobs:
             --api-secret "$LIVEKIT_API_SECRET" \
             --default
 
+      - name: Regenerate livekit.toml from playground.yaml
+        run: |
+          python3 -m pip install --quiet pyyaml
+          python3 <<'PY'
+          import yaml
+          from pathlib import Path
+          data = yaml.safe_load(Path("examples/playground.yaml").read_text())
+          subdomain = data["project"]["subdomain"]
+          slug = "${{ matrix.example }}"
+          entry = data["examples"][slug]
+          toml = (
+              "[project]\n"
+              f'  subdomain = "{subdomain}"\n'
+              "\n"
+              "[agent]\n"
+              f'  id = "{entry["agent_id"]}"\n'
+          )
+          Path(f"examples/{slug}/livekit.toml").write_text(toml)
+          print(f"wrote examples/{slug}/livekit.toml")
+          PY
+
       - name: Build secrets file
         working-directory: examples/${{ matrix.example }}
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
         run: |
           : > .env.deploy
+          # Register the agent under a deterministic name so the playground
+          # can dispatch to it explicitly. Matches the slug in playground.yaml.
+          echo "LIVEKIT_AGENT_NAME=${{ matrix.example }}" >> .env.deploy
           case "${{ matrix.example }}" in
             healthcare)
               keys="OPENAI_API_KEY"
@@ -76,3 +100,65 @@ jobs:
             args+=(--secrets-file .env.deploy)
           fi
           lk agent deploy "${args[@]}" .
+
+  publish-manifest:
+    name: Publish examples manifest to agents-jukebox
+    runs-on: ubuntu-latest
+    needs: deploy
+    if: ${{ always() && !cancelled() }}
+    steps:
+      - name: Checkout agents
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          ref: ${{ inputs.ref || 'main' }}
+          path: agents
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - run: python -m pip install --quiet pyyaml
+
+      - name: Build manifest
+        run: |
+          python <<'PY' > examples-manifest.json
+          # The playground links out to GitHub for source / README; we only
+          # need the yaml metadata in the manifest now.
+          import json, yaml
+          from pathlib import Path
+          root = Path("agents/examples")
+          m = yaml.safe_load((root / "playground.yaml").read_text())
+          print(json.dumps(m, indent=2, ensure_ascii=False))
+          PY
+
+      - name: Checkout agents-jukebox
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          repository: livekit/agents-jukebox
+          ssh-key: ${{ secrets.JUKEBOX_DEPLOY_KEY }}
+          path: jukebox
+
+      - name: Commit and push if changed
+        working-directory: jukebox
+        run: |
+          mkdir -p next/public
+          cp ../examples-manifest.json next/public/examples-manifest.json
+          git config user.name "livekit-examples-bot"
+          git config user.email "examples-bot@livekit.io"
+          git add next/public/examples-manifest.json
+          if git diff --cached --quiet; then
+            echo "Manifest unchanged, nothing to commit."
+            exit 0
+          fi
+          git commit -m "chore: refresh examples manifest"
+          for i in 1 2; do
+            if git push origin HEAD; then
+              echo "Pushed manifest update."
+              exit 0
+            fi
+            echo "Push failed (attempt $i), pulling and retrying..."
+            git pull --rebase origin HEAD
+          done
+          echo "Failed to push manifest after retries." >&2
+          exit 1

examples/drive-thru/Dockerfile

@@ -1,21 +1,14 @@
-# This is an example Dockerfile that builds a minimal container for running LK Agents
-# For more information on the build process, see https://docs.livekit.io/agents/ops/deployment/builds/
 # syntax=docker/dockerfile:1
-
-# Use the official Python base image with Python 3.13
-# We use the slim variant to keep the image size smaller while still having essential tools
+#
+# Shared Dockerfile for every example under examples/. Byte-identical
+# across the tree — each example's entry script is named `agent.py`,
+# so there's no per-example variation left.
 ARG PYTHON_VERSION=3.13
 FROM python:${PYTHON_VERSION}-slim AS base
 
-# Keeps Python from buffering stdout and stderr to avoid situations where
-# the application crashes without emitting any logs due to buffering.
 ENV PYTHONUNBUFFERED=1
-
-# Disable pip version check to speed up builds
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1
 
-# Create a non-privileged user that the app will run under.
-# See https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user
 ARG UID=10001
 RUN adduser \
     --disabled-password \
@@ -25,42 +18,22 @@ RUN adduser \
     --uid "${UID}" \
     appuser
 
-# Install build dependencies required for Python packages with native extensions
-# gcc: C compiler needed for building Python packages with C extensions
-# g++: C++ compiler needed for building Python packages with C++ extensions
-# python3-dev: Python development headers needed for compilation
-# We clean up the apt cache after installation to keep the image size down
 RUN apt-get update && apt-get install -y \
     gcc \
     g++ \
     python3-dev \
   && rm -rf /var/lib/apt/lists/*
 
-# Create a new directory for our application code
-# And set it as the working directory
 WORKDIR /app
-
-# Switch to the non-privileged user for all subsequent operations
-# This improves security by not running as root
 USER appuser
 
-# Copy just the dependency files first, for more efficient layer caching
 COPY requirements.txt ./
-
-# Install Python dependencies using pip
-# --no-cache-dir ensures we don't use the system cache
 RUN pip install --user --no-cache-dir -r requirements.txt
 
-# Pre-download any ML models or files the agent needs
-# This ensures the container is ready to run immediately without downloading
-# dependencies at runtime, which improves startup time and reliability
+# Pre-download model weights plugins ship (silero VAD, turn-detector, …)
+# so the container is ready to take traffic without a cold-download stall.
 RUN python -m livekit.agents download-files
 
-# Copy all remaining pplication files into the container
-# This includes source code, configuration files, and dependency specifications
-# (Excludes files specified in .dockerignore)
 COPY . .
 
-# Run the application
-# The "start" command tells the worker to connect to LiveKit and begin waiting for jobs.
 CMD ["python", "agent.py", "start"]

examples/drive-thru/agent.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import logging
 import os
@@ -379,6 +380,62 @@ async def list_order_items(self, ctx: RunContext[Userdata]) -> str:
         return "\n".join(item.model_dump_json() for item in items)
 
 
+def _find(items: list[MenuItem], id: str, size=None) -> MenuItem | None:
+    found = find_items_by_id(items, id, size)
+    return found[0] if found else None
+
+
+def format_cart(userdata: Userdata) -> str:
+    """Render the current order as markdown for the playground card.
+
+    Returns an empty string when the cart is empty, which signals the
+    UI to hide the card. The card itself already shows "Current order"
+    in its title bar, so the body skips a heading and goes straight to
+    the line items.
+    """
+    if not userdata.order.items:
+        return ""
+    lines: list[str] = []
+    total = 0.0
+    for item in userdata.order.items.values():
+        if isinstance(item, OrderedCombo):
+            meal = _find(userdata.combo_items, item.meal_id)
+            drink = _find(userdata.drink_items, item.drink_id, item.drink_size)
+            extras = [f"fries {item.fries_size}"]
+            if drink:
+                extras.append(f"{drink.name} ({item.drink_size})")
+            if item.sauce_id:
+                sauce = _find(userdata.sauce_items, item.sauce_id)
+                if sauce:
+                    extras.append(sauce.name)
+            name = meal.name if meal else item.meal_id
+            price = meal.price if meal else 0.0
+        elif isinstance(item, OrderedHappy):
+            meal = _find(userdata.happy_items, item.meal_id)
+            drink = _find(userdata.drink_items, item.drink_id, item.drink_size)
+            extras = []
+            if drink:
+                extras.append(f"{drink.name} ({item.drink_size})")
+            if item.sauce_id:
+                sauce = _find(userdata.sauce_items, item.sauce_id)
+                if sauce:
+                    extras.append(sauce.name)
+            name = meal.name if meal else item.meal_id
+            price = meal.price if meal else 0.0
+        else:
+            assert isinstance(item, OrderedRegular)
+            reg = _find(userdata.regular_items, item.item_id, item.size)
+            name = reg.name if reg else item.item_id
+            price = reg.price if reg else 0.0
+            extras = [f"size {item.size}"] if item.size else []
+        total += price
+        extras_str = f" · {', '.join(extras)}" if extras else ""
+        lines.append(f"- **{name}**{extras_str} · [[${price:.2f}]]")
+    lines.append("")
+    lines.append(f"**Total · [[${total:.2f}]]**")
+    return "\n".join(lines)
+
+
 async def new_userdata() -> Userdata:
     fake_db = FakeDB()
     drink_items = await fake_db.list_drinks()
@@ -442,6 +499,54 @@ async def drive_thru_agent(ctx: JobContext) -> None:
         ),
     )
 
+    # Push the cart as markdown to the playground's cart view
+    # whenever it changes. Coalesced + serialized: rapid changes
+    # (e.g. batch-remove that pops items one at a time) collapse
+    # into a single trailing push of the *latest* cart state, so
+    # an empty-cart payload can't get reordered behind a stale
+    # mid-state push. Fire-and-forget at the call site — the
+    # function tool that mutated the order shouldn't block on the
+    # RPC round-trip.
+    push_pending = False
+    push_running = False
+
+    async def _push_to(identity: str, payload: str) -> None:
+        try:
+            await ctx.room.local_participant.perform_rpc(
+                destination_identity=identity,
+                method="set_cart_content",
+                payload=payload,
+            )
+        except Exception:
+            logger.exception("cart push to %s failed", identity)
+
+    async def _push_runner() -> None:
+        nonlocal push_pending, push_running
+        push_running = True
+        try:
+            while push_pending:
+                push_pending = False
+                payload = format_cart(userdata)
+                logger.info("push_cart: %d chars", len(payload))
+                peers = list(ctx.room.remote_participants.values())
+                if not peers:
+                    continue
+                await asyncio.gather(
+                    *(_push_to(p.identity, payload) for p in peers),
+                    return_exceptions=True,
+                )
+        finally:
+            push_running = False
+
+    async def push_cart() -> None:
+        nonlocal push_pending
+        push_pending = True
+        if push_running:
+            return
+        asyncio.create_task(_push_runner())
+
+    userdata.order.on_change = push_cart
+
     await session.start(agent=DriveThruAgent(userdata=userdata), room=ctx.room)
     await background_audio.start(room=ctx.room, agent_session=session)
 

examples/drive-thru/order.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
+import logging
 import secrets
 import string
-from dataclasses import dataclass
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
 from typing import Annotated, Literal
 
 from pydantic import BaseModel, Field
 
+logger = logging.getLogger("drive-thru.order")
+
 
 def order_uid() -> str:
     alphabet = string.ascii_uppercase + string.digits  # b36
@@ -45,12 +49,27 @@ class OrderedRegular(BaseModel):
 @dataclass
 class OrderState:
     items: dict[str, OrderedItem]
+    # Optional async hook fired after every add/remove. The agent
+    # wires this up to push the current cart to the playground UI;
+    # exceptions inside the hook never block the order mutation.
+    on_change: Callable[[], Awaitable[None]] | None = field(default=None)
+
+    async def _fire(self) -> None:
+        if self.on_change is None:
+            return
+        try:
+            await self.on_change()
+        except Exception:
+            logger.exception("OrderState.on_change failed")
 
     async def add(self, item: OrderedItem) -> None:
         self.items[item.order_id] = item
+        await self._fire()
 
     async def remove(self, order_id: str) -> OrderedItem:
-        return self.items.pop(order_id)
+        removed = self.items.pop(order_id)
+        await self._fire()
+        return removed
 
     def get(self, order_id: str) -> OrderedItem | None:
         return self.items[order_id]