Quickstart

pip install "menlo-robot-sdk[livekit]"

python -c "import menlo_robot_sdk; print(menlo_robot_sdk.__version__)"

export MENLO_API_KEY="sk_live_..."
export MENLO_RCS_URL="https://api.menlo.ai/rcs"

import asyncio
import time
from menlo_robot_sdk import AsyncClient, connect
from menlo_robot_sdk.experimental import generate_room_key

async def wait_for_skills(session, timeout_s: float = 180.0):
    """Wait for the browser viewer to join and skills to become available."""
    deadline = time.monotonic() + timeout_s
    print("Waiting for browser to join...")
    while time.monotonic() < deadline:
        try:
            found = await session.discover_skills()
            if found:
                return found
        except (RuntimeError, TimeoutError):
            pass  # viewer not joined yet
        await asyncio.sleep(2.0)
    raise TimeoutError("viewer did not join — is the Chrome tab open?")

async def main():
    # Create client with API key from environment
    async with AsyncClient() as client:
        # Create a virtual robot
        created = await client.robots.create(name="my-robot", model="asimov-v0")
        robot_id = created.robot.id
        print(f"Created robot: {robot_id}")

        # Connect to the robot (browser viewer becomes the runtime)
        session = await connect(
            client,
            robot_id,
            worker_names=[],  # Empty - browser viewer is the runtime
            rcw_identity_prefix="simplesim",
            join_livekit=True,
        )

        # Generate a room key for the viewer
        key = await generate_room_key(client, robot_id)
        print(f"\nOpen in Chrome: https://sim.menlo.ai/?key={key}")
        print("(That tab becomes the robot runtime)\n")

        # Wait for skills (browser joins as runtime)
        skills = await wait_for_skills(session)
        print(f"Available skills: {[s.name for s in skills]}")

        # Drive the robot forward
        result = await session.invoke("set_velocity", {"vx": 0.5, "duration_s": 2.0})
        print(f"Action result: {result.status}")

        # Clean up
        await session.disconnect()
        await client.robots.delete(robot_id)

if __name__ == "__main__":
    asyncio.run(main())