Vexa Documentation

The meeting-api is a Python-based domain service (built with FastAPI) that manages the entire lifecycle of meeting bots and transcription data. It acts as a modular monolith responsible for three primary functions:

1. Bot Lifecycle Management: Spawning meeting bots via runtime.v1, driving their Finite State Machines (FSM) using lifecycle.v1 callbacks, and handling bot termination.
2. Transcription Collection: Draining the transcription_segments Redis stream into a database and publishing live transcripts.
3. Read Surface: Providing APIs for dashboards and agents to query meeting history and transcripts via GET /meetings and GET /transcripts.

The service is designed to run within the bot-manager and transcription-collector ecosystem using FastAPI, Redis, and a database.

The core/gateway serves as the production edge of the Vexa control plane. It handles authentication, routing, and WebSocket (WS) fan-out.

Key responsibilities include:

• Authentication: Resolves the caller's x-api-key (fail-closed) and enforces per-route scopes.
• REST Proxying: Proxies the CORE REST surface to the meeting-api verbatim, injecting x-user-* identity headers.
• WebSocket Multiplexing: Runs the /ws multiplex that fans out per-meeting Redis channels to clients over a single socket.
• Observability: Mints an X-Trace-Id at the edge and forwards it downstream for tracing.

The Vexa Bot is an ephemeral, disposable meeting-joining and capture worker written in Node/TypeScript. It is designed to boot from a single configuration, join a video conferencing platform (Google Meet, Zoom, or Teams) using a humanized browser, capture audio, transcribe it using @vexa/transcribe-whisper, and publish results before terminating.

It operates as a modular monolith where the orchestrator core is decoupled from adapters (browser, Redis, HTTP) via ports, allowing for offline-provable logic.

The gmeet-capture package provides the browser-side logic for capturing audio from Google Meet. It is composed of several specialized modules:

• pcm-capture.ts: Handles per-element AudioContext to produce 16 kHz PCM audio using an AudioWorklet (loaded via a host-supplied moduleUrl under MV3 or a blob: URL).
• gmeet-capture.ts: Manages the rescanning of the meeting interface and the wiring of per-channel audio.
• gmeet-speakers.ts: Manages the 'live glow' UI (visual indicators of active speakers).
• gmeet-capture-v1.ts: Contains pure attribution logic, including the capture.v1 producer and the pickBoundName function.
• gmeet-channel-binder.ts: Implements DOM-free energy-to-glow correlation logic.

The Vexa extension is an in-tab Google Meet capture driver built using Manifest V3 (MV3). It functions as a client application rather than a library.

Key Capabilities:

• Captures live page audio directly from the Google Meet tab (no bot required).
• Captures each participant's audio on a per-channel basis, along with your own microphone.
• Streams data using the capture.v1 format via a WebSocket to the Vexa desktop host.
• Uses @vexa/gmeet-capture for per-participant capture and speaker identification.
• Uses @vexa/capture-codec for the capture.v1 binary-frame and JSON-event wire codec.

Note: This extension is designed exclusively for Google Meet; it does not support Zoom, Teams, or standard recording paths.

The admin_api is the identity service package for Vexa. It provides the FastAPI surface for managing identities and handles token minting for different scopes. The package is structured into three main components:

• Schema Management: Uses SQLAlchemy (v0.12) as the source-of-truth, providing an idempotent ensure_schema() function to manage database state.
• API Surface: A FastAPI application created via create_app, which includes injectable asynchronous database wiring.
• Token Scoping: Implements vxa_<scope>_ token minting for specific operational scopes: bot, tx, and browser.

The vexa_slim package is a curated, minimal verb surface designed for scripting and cookbook flows. It provides a lightweight way to interact with the Vexa API without the full complexity of the main client.

The package is organized into the following modules:

• client: The core HTTP client for making requests to the Vexa API.
• cli / __main__: The command-line interface entry point.
• config: Configuration management.
• cookbook: Provides L0–L3 verbs for executing predefined workflows.
• harvest: Tools for data collection/extraction.
• models: Data models used throughout the package.