@lofcz/orb-ui 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,330 @@
+# orb-ui
+
+**Voice agent UI that feels alive.**
+
+Expressive, accessible React components for realtime voice agents. Connect Vapi, ElevenLabs, LiveKit, Pipecat, OpenAI Realtime, Gemini Live, or your own voice stack through one consistent UI layer.
+
+<p align="center">
+  <a href="https://orb-ui.com">
+    <img src="demo/public/og-image-v2.jpg" alt="orb-ui — Voice agent UI that feels alive" width="900" />
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://orb-ui.com">Live demo</a> · <a href="https://orb-ui.com/docs">Documentation</a> · <a href="https://orb-ui.com/playground">Playground</a> · <a href="https://www.npmjs.com/package/@lofcz/orb-ui">npm</a> · <a href="https://github.com/lofcz/orb-ui">Star on GitHub</a>
+</p>
+
+```jsx
+import Vapi from '@vapi-ai/web'
+import { Orb } from '@lofcz/orb-ui'
+import { createVapiAdapter } from '@lofcz/orb-ui/adapters'
+
+const vapi = new Vapi('your-public-key')
+const adapter = createVapiAdapter(vapi, { assistantId: 'your-assistant-id' })
+
+export function VoiceOrb() {
+  return <Orb adapter={adapter} theme="circle" aria-label="Start voice assistant" />
+}
+```
+
+## Install
+
+Install the component package:
+
+```bash
+bun add @lofcz/orb-ui
+```
+
+Provider adapters are lightweight wrappers around provider SDKs. Install the SDK for the provider you use:
+
+```bash
+# Vapi
+bun add @lofcz/orb-ui @vapi-ai/web
+
+# ElevenLabs Conversational AI
+bun add @lofcz/orb-ui @elevenlabs/client
+
+# LiveKit Agents
+bun add @lofcz/orb-ui livekit-client
+
+# Pipecat (choose the transport used by your agent)
+bun add @lofcz/orb-ui @pipecat-ai/client-js @pipecat-ai/small-webrtc-transport
+
+# OpenAI Realtime uses browser WebRTC and has no additional client SDK
+bun add @lofcz/orb-ui
+
+# Gemini Live
+bun add @lofcz/orb-ui @google/genai
+```
+
+> **Note:** Orb uses React hooks internally — in Next.js App Router, use it in a `'use client'` component.
+
+## How provider adapters are created
+
+Every provider ends at the same React API:
+
+```jsx
+<Orb adapter={adapter} theme="circle" aria-label="Start voice assistant" />
+```
+
+The only difference is how the adapter obtains a provider session:
+
+| Provider                                                                  | Required browser setup                                                   |
+| ------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+| [Vapi guide](https://orb-ui.com/docs/adapters/vapi)                       | Pass a configured Vapi client plus `assistantId`                         |
+| [ElevenLabs guide](https://orb-ui.com/docs/adapters/elevenlabs)           | Pass `Conversation` plus an `agentId`, signed URL, or conversation token |
+| [LiveKit guide](https://orb-ui.com/docs/adapters/livekit)                 | Provide a token endpoint and optional agent name                         |
+| [Pipecat guide](https://orb-ui.com/docs/adapters/pipecat)                 | Pass a configured `PipecatClient` plus its connect callback              |
+| [OpenAI Realtime guide](https://orb-ui.com/docs/adapters/openai-realtime) | Return a fresh short-lived client secret from `getClientSecret`          |
+| [Gemini Live guide](https://orb-ui.com/docs/adapters/gemini-live)         | Open the official Google Live session in `connect`                       |
+
+The adapter owns provider event mapping and emits one consistent `OrbSignal`. OpenAI and Gemini
+standard API keys, and LiveKit participant-token signing, stay on your server. See the
+[adapter overview](https://orb-ui.com/docs/adapters/overview) for the responsibility boundary and
+advanced setup shapes.
+
+For an app-owned WebRTC, WebSocket, telephony, or speech runtime, follow the
+[custom integration guide](https://orb-ui.com/docs/adapters/custom).
+
+## Quick Start
+
+Use orb-ui as a React voice AI component when you need a first-party provider voice UI or a custom animated voice orb for another realtime voice agent stack.
+
+### With Vapi
+
+```jsx
+import Vapi from '@vapi-ai/web'
+import { Orb } from '@lofcz/orb-ui'
+import { createVapiAdapter } from '@lofcz/orb-ui/adapters'
+
+const vapi = new Vapi('your-public-key')
+const adapter = createVapiAdapter(vapi, { assistantId: 'your-assistant-id' })
+
+function App() {
+  return <Orb adapter={adapter} theme="circle" aria-label="Start Vapi assistant" />
+}
+```
+
+### With ElevenLabs
+
+```jsx
+import { Conversation } from '@elevenlabs/client'
+import { Orb } from '@lofcz/orb-ui'
+import { createElevenLabsAdapter } from '@lofcz/orb-ui/adapters'
+
+const adapter = createElevenLabsAdapter(Conversation, { agentId: 'your-agent-id' })
+
+function App() {
+  return <Orb adapter={adapter} theme="circle" aria-label="Start ElevenLabs assistant" />
+}
+```
+
+### With LiveKit
+
+```jsx
+import { Orb } from '@lofcz/orb-ui'
+import { createLiveKitAdapter } from '@lofcz/orb-ui/adapters/livekit'
+
+const adapter = createLiveKitAdapter({
+  tokenEndpoint: '/api/livekit-token',
+  agentName: 'your-agent-name',
+})
+
+function App() {
+  return <Orb adapter={adapter} theme="circle" aria-label="Start LiveKit assistant" />
+}
+```
+
+The LiveKit entrypoint creates the room and token source, assigns a fresh room name, and meters both
+sides of the conversation with speech-oriented analyser and smoothing defaults. Existing-room and
+custom-runtime modes remain available from the advanced `@lofcz/orb-ui/adapters` entrypoint.
+
+### With Pipecat
+
+```jsx
+import { PipecatClient } from '@pipecat-ai/client-js'
+import { SmallWebRTCTransport } from '@pipecat-ai/small-webrtc-transport'
+import { Orb } from '@lofcz/orb-ui'
+import { createPipecatAdapter } from '@lofcz/orb-ui/adapters'
+
+const client = new PipecatClient({ transport: new SmallWebRTCTransport(), enableMic: true })
+const adapter = createPipecatAdapter(client, {
+  connect: () => client.connect({ webrtcUrl: 'https://agent.example.com/api/offer' }),
+})
+
+function App() {
+  return <Orb adapter={adapter} theme="circle" aria-label="Start Pipecat assistant" />
+}
+```
+
+The Pipecat adapter consumes the standard RTVI event surface and meters the client media tracks as
+a browser fallback, so it works with Pipecat Cloud, Daily, SmallWebRTC, and transports that emit
+sparse audio-level events. See the [Pipecat guide](https://orb-ui.com/docs/adapters/pipecat).
+
+### With OpenAI Realtime
+
+```jsx
+import { Orb } from '@lofcz/orb-ui'
+import { createOpenAIRealtimeAdapter } from '@lofcz/orb-ui/adapters'
+
+const adapter = createOpenAIRealtimeAdapter({
+  getClientSecret: async () => {
+    const response = await fetch('/api/openai-realtime-token', { method: 'POST' })
+    return (await response.json()).value
+  },
+})
+```
+
+Create client secrets with a standard OpenAI API key on your server. See the
+[OpenAI Realtime guide](https://orb-ui.com/docs/adapters/openai-realtime).
+
+### With Gemini Live
+
+```jsx
+import { GoogleGenAI } from '@google/genai'
+import { Orb } from '@lofcz/orb-ui'
+import { createGeminiLiveAdapter } from '@lofcz/orb-ui/adapters'
+
+const adapter = createGeminiLiveAdapter({
+  connect: async (callbacks) => {
+    const token = await fetch('/api/gemini-live-token', { method: 'POST' }).then((res) =>
+      res.json(),
+    )
+    const client = new GoogleGenAI({
+      apiKey: token.value,
+      httpOptions: { apiVersion: 'v1alpha' },
+    })
+    return client.live.connect({ model: token.model, config: token.config, callbacks })
+  },
+})
+```
+
+Mint one-use Gemini Live tokens on your server. See the
+[Gemini Live guide](https://orb-ui.com/docs/adapters/gemini-live) for the matching server config that
+disables automatic activity detection. The adapter handles client-side turn detection by default.
+
+The examples above show the intended happy paths. Transport overrides, custom browser runtimes,
+existing-session modes, and audio calibration hooks are optional and documented in the individual
+adapter guides.
+
+### Controlled mode (custom integration)
+
+```jsx
+import { Orb } from '@lofcz/orb-ui'
+import { useState } from 'react'
+
+function App() {
+  const [state, setState] = useState('idle')
+  const [volume, setVolume] = useState(0)
+
+  return <Orb state={state} volume={volume} theme="circle" />
+}
+```
+
+Use `signal` when your integration has separate input and output levels:
+
+```jsx
+import { Orb } from '@lofcz/orb-ui'
+
+function App() {
+  return <Orb signal={{ state: 'speaking', outputVolume: 0.7 }} theme="circle" />
+}
+```
+
+### External session controls
+
+Keep the orb as a passive visual when start and stop controls belong elsewhere in your layout.
+Provider adapters already expose the matching lifecycle methods.
+
+```jsx
+function VoiceExperience({ adapter }) {
+  return (
+    <>
+      <Orb adapter={adapter} theme="cloud" interactive={false} />
+      <button onClick={() => void adapter.start?.()}>Start conversation</button>
+      <button onClick={() => void adapter.stop?.()}>End conversation</button>
+    </>
+  )
+}
+```
+
+## Themes
+
+| Theme    | Description                                                                   |
+| -------- | ----------------------------------------------------------------------------- |
+| `radial` | Four-lobe radial field with input-reactive rim and output-reactive twisting.  |
+| `cloud`  | Atmospheric sphere with inverse listening scale and faster speaking motion.   |
+| `debug`  | State + volume display with start/stop. Use to verify your integration works. |
+| `circle` | Pulsing circle that reacts to volume.                                         |
+| `bars`   | Five bars that animate with voice.                                            |
+
+When an adapter or `onStart`/`onStop` handler is provided, visual themes include keyboard-accessible `<button type="button">` controls. `radial` places its phone control below the artwork while the other clickable themes use the visual itself. Pass `interactive={false}` to keep the theme passive and call `adapter.start()` or `adapter.stop()` from external controls instead.
+
+The radial phone control uses a small cutout that defaults to white. Match it to the surface behind
+the orb with the typed style variable:
+
+```tsx
+<Orb adapter={adapter} theme="radial" style={{ '--orb-ui-radial-control-surround': '#101010' }} />
+```
+
+## Props
+
+| Prop          | Type                                                   | Default   | Description                                             |
+| ------------- | ------------------------------------------------------ | --------- | ------------------------------------------------------- |
+| `theme`       | `'debug' \| 'circle' \| 'bars' \| 'cloud' \| 'radial'` | `'debug'` | Visual theme                                            |
+| `signal`      | `OrbSignal`                                            | —         | Rich controlled signal with state/input/output volume   |
+| `state`       | `OrbState`                                             | `'idle'`  | Conversation state (controlled mode)                    |
+| `volume`      | `number`                                               | `0`       | Audio volume, 0–1. Overrides signal/adapter volume.     |
+| `adapter`     | `OrbAdapter`                                           | —         | Provider adapter (manages signal updates automatically) |
+| `size`        | `number`                                               | `200`     | Size in pixels                                          |
+| `className`   | `string`                                               | —         | Optional class name for the rendered theme              |
+| `style`       | `OrbStyle`                                             | —         | Inline styles, including radial control surround color  |
+| `disabled`    | `boolean`                                              | `false`   | Disables clickable themes and debug start/stop controls |
+| `interactive` | `boolean`                                              | `true`    | Allows the theme control to start and stop a session    |
+| `aria-label`  | `string`                                               | generated | Accessible label for clickable visual themes            |
+| `onStart`     | `() => void`                                           | —         | Custom start handler (overrides adapter.start())        |
+| `onStop`      | `() => void`                                           | —         | Custom stop handler (overrides adapter.stop())          |
+
+## States
+
+`idle` · `connecting` · `listening` · `thinking` · `speaking` · `error`
+
+## Supported Providers
+
+| Provider                                                                  | Adapter                                                               |
+| ------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| [Vapi](https://vapi.ai)                                                   | `createVapiAdapter` from `@lofcz/orb-ui/adapters`                            |
+| [ElevenLabs](https://elevenlabs.io/conversational-ai)                     | `createElevenLabsAdapter` from `@lofcz/orb-ui/adapters`                      |
+| [LiveKit](https://livekit.io)                                             | `createLiveKitAdapter` from `@lofcz/orb-ui/adapters`                         |
+| [Pipecat](https://pipecat.ai)                                             | `createPipecatAdapter` from `@lofcz/orb-ui/adapters`                         |
+| [OpenAI Realtime](https://developers.openai.com/api/docs/guides/realtime) | `createOpenAIRealtimeAdapter` from `@lofcz/orb-ui/adapters`                  |
+| [Gemini Live](https://ai.google.dev/gemini-api/docs/live-api)             | `createGeminiLiveAdapter` from `@lofcz/orb-ui/adapters`                      |
+| Custom                                                                    | Use controlled mode — pass `signal`, or `state` and `volume` directly |
+
+## Development
+
+```bash
+git clone https://github.com/lofcz/orb-ui.git
+cd orb-ui
+bun install
+
+# Build the library
+bun run build
+
+# Run demo locally
+bun run dev:demo
+```
+
+Useful maintenance commands:
+
+```bash
+bun run check     # format check, lint, typechecks, tests, library build, demo build
+bun run format    # format repo files
+```
+
+Releases are published as `@lofcz/orb-ui` from GitHub Actions (`release.yml`)
+using npm trusted publishing (OIDC). Run **Release and Publish to npm** on `main`.
+
+## License
+
+MIT © [Alexander Chen](https://github.com/alexanderqchen)

package/dist/adapters/audio-level.d.ts

@@ -0,0 +1,28 @@
+export interface OutputVolumeCalibration {
+    /** Raw RMS values at or below this level are treated as silence. */
+    noiseFloor: number;
+    /** Multiplier applied after the noise floor. */
+    gain: number;
+    /** Power curve applied after gain. Values below 1 lift quieter speech. */
+    exponent: number;
+    /** EMA rate used while the volume is rising. */
+    attack: number;
+    /** EMA rate used while the volume is falling. */
+    release: number;
+}
+export type OutputVolumeCalibrationSource = Partial<OutputVolumeCalibration> | (() => Partial<OutputVolumeCalibration>);
+export interface OutputVolumeSample {
+    /** Unmodified RMS value measured from the provider audio stream. */
+    raw: number;
+    /** Value after noise floor, gain, and power-curve shaping. */
+    shaped: number;
+    /** Final value after attack/release smoothing. */
+    normalized: number;
+}
+export interface MediaStreamTrackVolumeMeter {
+    stop(): Promise<void>;
+}
+export type AudioContextSource = () => AudioContext | undefined;
+export declare const DEFAULT_OUTPUT_VOLUME_CALIBRATION: OutputVolumeCalibration;
+export declare function calibrateOutputVolume(rawValue: number, previous: number, source?: OutputVolumeCalibrationSource): OutputVolumeSample;
+export declare function createMediaStreamTrackVolumeMeter(track: MediaStreamTrack, createAudioContext: AudioContextSource, onVolume: (volume: number) => void): MediaStreamTrackVolumeMeter | undefined;

package/dist/adapters/elevenlabs/index.d.ts

@@ -0,0 +1,85 @@
+import { OrbAdapter } from '../types.js';
+export type ElevenLabsMode = 'speaking' | 'listening';
+export type ElevenLabsStatus = 'disconnected' | 'connecting' | 'connected' | 'disconnecting';
+export type ElevenLabsConnectionType = 'websocket' | 'webrtc';
+export interface ElevenLabsCallbacks {
+    onConnect?: (props: {
+        conversationId: string;
+    }) => void;
+    onDisconnect?: (details: unknown) => void;
+    onError?: (message: string, context?: unknown) => void;
+    onModeChange?: (prop: {
+        mode: ElevenLabsMode;
+    }) => void;
+    onStatusChange?: (prop: {
+        status: ElevenLabsStatus;
+    }) => void;
+    onVadScore?: (props: {
+        vadScore: number;
+    }) => void;
+}
+export interface ElevenLabsConversation {
+    endSession(): Promise<void>;
+    getInputVolume(): number;
+    getOutputVolume(): number;
+    getInputByteFrequencyData(): Uint8Array;
+    getOutputByteFrequencyData(): Uint8Array;
+}
+type ElevenLabsSessionAuth = {
+    agentId: string;
+    signedUrl?: never;
+    conversationToken?: never;
+    connectionType?: ElevenLabsConnectionType;
+} | {
+    signedUrl: string;
+    agentId?: never;
+    conversationToken?: never;
+    connectionType?: 'websocket';
+} | {
+    conversationToken: string;
+    agentId?: never;
+    signedUrl?: never;
+    connectionType?: 'webrtc';
+};
+export type ElevenLabsConfig = ElevenLabsSessionAuth & {
+    /** orb-ui expects a voice conversation, so text-only sessions are intentionally unsupported. */
+    textOnly?: false;
+    /** Allow @elevenlabs/client startSession options that orb-ui does not inspect. */
+    [key: string]: unknown;
+};
+export type ElevenLabsStartSessionOptions = ElevenLabsConfig & ElevenLabsCallbacks;
+export interface ElevenLabsConversationClass {
+    startSession(options: ElevenLabsStartSessionOptions): Promise<ElevenLabsConversation>;
+}
+export interface ElevenLabsOrbAdapter extends OrbAdapter {
+    /** Start an ElevenLabs conversation. Called automatically by Orb on click. */
+    start(): Promise<void>;
+    /** Stop the current ElevenLabs conversation. Called automatically by Orb on click. */
+    stop(): Promise<void>;
+}
+/**
+ * Creates an OrbAdapter for ElevenLabs Conversational AI.
+ *
+ * Unlike createVapiAdapter, this adapter owns the session lifecycle because
+ * ElevenLabs requires callbacks to be injected at Conversation.startSession()
+ * time. Pass the returned adapter to Orb and Orb will call start()/stop()
+ * when the clickable theme is activated.
+ *
+ * @param ConversationClass - The Conversation class from @elevenlabs/client
+ * @param config            - agentId / signedUrl + any other startSession options
+ *
+ * @example
+ * import { Conversation } from '@elevenlabs/client'
+ * import { Orb } from '@lofcz/orb-ui'
+ * import { createElevenLabsAdapter } from '@lofcz/orb-ui/adapters'
+ *
+ * const adapter = createElevenLabsAdapter(Conversation, {
+ *   agentId: 'your-agent-id',
+ * })
+ *
+ * function App() {
+ *   return <Orb adapter={adapter} theme="circle" aria-label="Start ElevenLabs assistant" />
+ * }
+ */
+export declare function createElevenLabsAdapter(ConversationClass: ElevenLabsConversationClass, config: ElevenLabsConfig): ElevenLabsOrbAdapter;
+export {};

package/dist/adapters/gemini-live/index.d.ts

@@ -0,0 +1,70 @@
+import { OrbAdapter } from '../types.js';
+import { OutputVolumeCalibrationSource, OutputVolumeSample } from '../audio-level.js';
+export interface GeminiLiveInlineData {
+    data?: string;
+    mimeType?: string;
+}
+export interface GeminiLiveServerMessage {
+    setupComplete?: unknown;
+    serverContent?: {
+        modelTurn?: {
+            parts?: Array<{
+                inlineData?: GeminiLiveInlineData;
+            }>;
+        };
+        turnComplete?: boolean;
+        generationComplete?: boolean;
+        interrupted?: boolean;
+        waitingForInput?: boolean;
+    };
+}
+export interface GeminiLiveCallbacks {
+    onopen?: () => void;
+    onmessage: (message: GeminiLiveServerMessage) => void;
+    onerror?: (error: unknown) => void;
+    onclose?: (event: unknown) => void;
+}
+export interface GeminiLiveSession {
+    sendRealtimeInput(input: {
+        audio?: {
+            data: string;
+            mimeType: string;
+        };
+        audioStreamEnd?: boolean;
+        activityStart?: Record<string, never>;
+        activityEnd?: Record<string, never>;
+    }): void;
+    close(): void;
+}
+export interface GeminiLiveAdapterConfig {
+    /** Connects an official Google GenAI Live session using the supplied callbacks. */
+    connect(callbacks: GeminiLiveCallbacks): Promise<GeminiLiveSession>;
+    /** Defaults to `{ audio: true }`. */
+    mediaStreamConstraints?: MediaStreamConstraints;
+    /** Defaults to 16 kHz PCM input, as recommended by Gemini Live. */
+    inputSampleRate?: number;
+    /** Defaults to 0.04 normalized input volume. */
+    speechThreshold?: number;
+    /** Defaults to 500 ms before listening transitions to thinking. */
+    speechEndDelayMs?: number;
+    /** Defaults to client-side detection. Use `server` with Gemini automatic activity detection. */
+    activityDetection?: 'client' | 'server';
+    /** Runtime override for tests or custom browser wrappers. */
+    getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+    /** Runtime override for tests or custom browser wrappers. */
+    createAudioContext?: () => AudioContext;
+    /** Optional live-tunable output shaping. A getter is read for every meter sample. */
+    outputVolumeCalibration?: OutputVolumeCalibrationSource;
+    /** Receives raw, shaped, and smoothed output levels for diagnostics. */
+    onOutputVolumeSample?: (sample: OutputVolumeSample) => void;
+}
+export interface GeminiLiveOrbAdapter extends OrbAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+/**
+ * Creates a managed browser-audio adapter for Gemini Live. The app owns token
+ * creation and the official GenAI client; orb-ui owns microphone streaming,
+ * PCM playback, volume metering, and normalized voice state.
+ */
+export declare function createGeminiLiveAdapter(config: GeminiLiveAdapterConfig): GeminiLiveOrbAdapter;

package/dist/adapters/index.d.ts

@@ -0,0 +1,8 @@
+export { createVapiAdapter } from './vapi/index.js';
+export { createElevenLabsAdapter, type ElevenLabsCallbacks, type ElevenLabsConfig, type ElevenLabsConnectionType, type ElevenLabsConversation, type ElevenLabsConversationClass, type ElevenLabsMode, type ElevenLabsOrbAdapter, type ElevenLabsStartSessionOptions, type ElevenLabsStatus, } from './elevenlabs/index.js';
+export { createLiveKitAdapter, type LiveKitAdapterConfig, type LiveKitConnectionDetails, type LiveKitOrbAdapter, type LiveKitResolvedTokenOptions, type LiveKitTokenOptions, type LiveKitTokenSource, } from './livekit/index.js';
+export { createPipecatAdapter, type PipecatAdapterOptions, type PipecatClientLike, type PipecatOrbAdapter, type PipecatParticipantLike, type PipecatTracksLike, } from './pipecat/index.js';
+export { createOpenAIRealtimeAdapter, type OpenAIRealtimeAdapterConfig, type OpenAIRealtimeClientSecret, type OpenAIRealtimeOrbAdapter, } from './openai-realtime/index.js';
+export { createGeminiLiveAdapter, type GeminiLiveAdapterConfig, type GeminiLiveCallbacks, type GeminiLiveInlineData, type GeminiLiveOrbAdapter, type GeminiLiveServerMessage, type GeminiLiveSession, } from './gemini-live/index.js';
+export { DEFAULT_OUTPUT_VOLUME_CALIBRATION, type OutputVolumeCalibration, type OutputVolumeCalibrationSource, type OutputVolumeSample, } from './audio-level.js';
+export type { OrbAdapter, OrbSignal, OrbSignalListener, OrbState } from './types.js';

package/dist/adapters/livekit/browser.d.ts

@@ -0,0 +1,49 @@
+import { LiveKitOrbAdapter, LiveKitTokenOptions } from './index.js';
+import { OutputVolumeCalibrationSource, OutputVolumeSample } from '../audio-level.js';
+interface LiveKitBrowserAdapterBase extends Omit<LiveKitTokenOptions, 'agentName' | 'roomName'> {
+    /** Agent dispatched into the room. Required for LiveKit Cloud sandbox sessions. */
+    agentName?: LiveKitTokenOptions['agentName'];
+    /** Defaults to a fresh `orb-<uuid>` room name for every start. */
+    roomName?: LiveKitTokenOptions['roomName'];
+    /** LiveKit room.connect options passed through unchanged. */
+    connectOptions?: Record<string, unknown>;
+    /** Enable the local microphone after connecting. Defaults to true. */
+    enableMicrophone?: boolean;
+    /** Optional live-tunable output shaping. A getter is read for every meter sample. */
+    outputVolumeCalibration?: OutputVolumeCalibrationSource;
+    /** Receives raw, shaped, and smoothed output levels for diagnostics. */
+    onOutputVolumeSample?: (sample: OutputVolumeSample) => void;
+}
+export type LiveKitTokenEndpointOptions = Omit<RequestInit, 'body'>;
+export interface LiveKitSandboxOptions {
+    /** Override LiveKit's default Cloud API base URL. */
+    baseUrl?: string;
+}
+export interface LiveKitEndpointAdapterConfig extends LiveKitBrowserAdapterBase {
+    /** LiveKit TokenSource endpoint returning `{ server_url, participant_token }`. */
+    tokenEndpoint: string;
+    /** Optional fetch settings such as authenticated request headers. */
+    tokenEndpointOptions?: LiveKitTokenEndpointOptions;
+    sandboxId?: never;
+    sandboxOptions?: never;
+}
+export interface LiveKitSandboxAdapterConfig extends LiveKitBrowserAdapterBase {
+    /** LiveKit Cloud sandbox token server ID. Sandbox mode is intended for testing only. */
+    sandboxId: string;
+    /** The agent to dispatch into the sandbox room. */
+    agentName: NonNullable<LiveKitTokenOptions['agentName']>;
+    /** Optional LiveKit sandbox host overrides. */
+    sandboxOptions?: LiveKitSandboxOptions;
+    tokenEndpoint?: never;
+    tokenEndpointOptions?: never;
+}
+export type LiveKitBrowserAdapterConfig = LiveKitEndpointAdapterConfig | LiveKitSandboxAdapterConfig;
+/**
+ * Creates a managed LiveKit Agents adapter using the official browser SDK.
+ *
+ * This entrypoint owns the LiveKit Room, token source, microphone, playback,
+ * and audio analysers. Import the advanced factory from `@lofcz/orb-ui/adapters`
+ * only when your application already owns those pieces.
+ */
+export declare function createLiveKitAdapter(config: LiveKitBrowserAdapterConfig): LiveKitOrbAdapter;
+export type { LiveKitOrbAdapter } from './index.js';