@vox-ai/client 0.1.0

package/README.md

@@ -0,0 +1,200 @@
+# @vox-ai/client
+
+vox.ai voice agent와 브라우저에서 직접 연결하기 위한 JavaScript SDK.
+
+## 설치
+
+```bash
+npm install @vox-ai/client
+# or
+yarn add @vox-ai/client
+# or
+pnpm add @vox-ai/client
+```
+
+## 빠른 시작
+
+```ts
+import { Conversation } from "@vox-ai/client";
+
+// 마이크 권한 요청 (UI에서 사전 안내 권장)
+await navigator.mediaDevices.getUserMedia({ audio: true });
+
+const conversation = await Conversation.startSession({
+  agentId: "YOUR_AGENT_ID",
+  apiKey: "YOUR_API_KEY",
+  onStatusChange: (status) => console.log("status:", status),
+  onModeChange: (mode) => console.log("mode:", mode),
+  onMessage: (message) => console.log(`${message.source}: ${message.text}`),
+  onError: (error) => console.error("error:", error.message),
+});
+```
+
+## 세션 옵션
+
+`Conversation.startSession(options)`에 전달하는 설정.
+
+| 옵션 | 타입 | 필수 | 설명 |
+|------|------|------|------|
+| `agentId` | `string` | O | Agent ID |
+| `apiKey` | `string` | O | API key |
+| `agentVersion` | `string` | | Agent version (`"current"`, `"production"`, `"v1"` 등, default: `"current"`) |
+| `textOnly` | `boolean` | | Text-only session (`true`면 mic/audio 없이 chat mode로 연결, default: `false`) |
+| `dynamicVariables` | `Record<string, string \| number \| boolean>` | | Agent prompt에 주입할 dynamic variables |
+| `metadata` | `Record<string, unknown>` | | Call metadata (webhook, call log에 포함) |
+
+## 콜백
+
+| 콜백 | 시그니처 | 설명 |
+|------|----------|------|
+| `onConnect` | `() => void` | 연결 성공 |
+| `onDisconnect` | `() => void` | 연결 종료 |
+| `onStatusChange` | `(status: ConversationStatus) => void` | Status 변경 (`"disconnected"` → `"connecting"` → `"connected"`) |
+| `onModeChange` | `(mode: ConversationMode) => void` | Mode 변경 (`"listening"` ⇄ `"speaking"`) |
+| `onMessage` | `(message: ConversationMessage) => void` | 메시지 수신 (user transcription, agent response) |
+| `onError` | `(error: Error) => void` | 에러 발생 |
+
+## 메서드
+
+### 세션 제어
+
+```ts
+// 세션 종료
+await conversation.endSession();
+
+// 세션 ID 조회
+const id = conversation.getId();
+
+// 현재 세션 메시지 조회
+const messages = conversation.getMessages();
+```
+
+### 메시지 전송
+
+```ts
+// 텍스트 메시지 전송 (음성 대신 텍스트 입력)
+await conversation.sendUserMessage("안녕하세요");
+```
+
+### 메시지 히스토리
+
+```ts
+const messages = conversation.getMessages();
+
+messages.forEach((message) => {
+  console.log(message.source, message.text, message.isFinal);
+});
+```
+
+- `getMessages()`는 현재 세션에서 주고받은 메시지를 timestamp 순으로 반환
+- 동일 `id`의 streaming update는 최신 메시지로 반영
+
+### Text Only
+
+```ts
+const conversation = await Conversation.startSession({
+  agentId: "YOUR_AGENT_ID",
+  apiKey: "YOUR_API_KEY",
+  textOnly: true,
+});
+
+await conversation.sendUserMessage("텍스트로만 대화할게요");
+```
+
+- text-only session은 microphone 권한을 요청하지 않음
+- 에이전트 응답은 LiveKit text stream으로 수신됨
+- audio 전용 API는 안전한 no-op 또는 zero-value를 반환
+
+### 마이크 제어
+
+```ts
+// 음소거
+await conversation.setMicMuted(true);
+
+// 음소거 해제
+await conversation.setMicMuted(false);
+
+// 현재 음소거 상태 조회
+const isMuted = conversation.getMicMuted();
+```
+
+### 볼륨 제어
+
+```ts
+// Agent 음성 볼륨 설정 (0.0 ~ 1.0)
+conversation.setVolume({ volume: 0.5 });
+```
+
+### 상태 조회
+
+```ts
+const status = conversation.getStatus(); // "disconnected" | "connecting" | "connected"
+const mode = conversation.getMode();     // "listening" | "speaking"
+```
+
+### 오디오 모니터링
+
+```ts
+// 입출력 볼륨 (0.0 ~ 1.0)
+const inputVol = conversation.getInputVolume();
+const outputVol = conversation.getOutputVolume();
+
+// Frequency data (Uint8Array, 시각화용)
+const inputFreq = conversation.getInputByteFrequencyData();
+const outputFreq = conversation.getOutputByteFrequencyData();
+```
+
+### 디바이스 전환
+
+```ts
+// 입력 디바이스 변경
+await conversation.changeInputDevice({ inputDeviceId: "device-id" });
+
+// 출력 디바이스 변경
+await conversation.changeOutputDevice({ outputDeviceId: "device-id" });
+```
+
+디바이스 목록은 [`navigator.mediaDevices.enumerateDevices()`](https://developer.mozilla.org/docs/Web/API/MediaDevices/enumerateDevices)로 조회.
+
+## Dynamic Variables / Metadata
+
+```ts
+const conversation = await Conversation.startSession({
+  agentId: "YOUR_AGENT_ID",
+  apiKey: "YOUR_API_KEY",
+  agentVersion: "production",
+  dynamicVariables: {
+    userName: "홍길동",
+    userType: "premium",
+    accountBalance: 50000,
+  },
+  metadata: {
+    sessionId: "sess_abc123",
+    source: "mobile-app",
+  },
+});
+```
+
+- `dynamicVariables` — Agent prompt에서 `{{userName}}` 형식으로 참조
+- `metadata` — Outbound webhook과 call log에 포함
+
+## Export 타입
+
+```ts
+import type {
+  ConversationMessage,
+  ConversationMode,
+  ConversationSource,
+  ConversationStatus,
+  InputDeviceConfig,
+  OutputDeviceConfig,
+  SetVolumeParams,
+  StartSessionOptions,
+} from "@vox-ai/client";
+```
+
+## 참고
+
+- 인증은 `apiKey` 직접 전달 방식
+- 내부 연결은 LiveKit WebRTC 기반
+- 브라우저별 audio device 제약이 있을 수 있음

package/dist/conversation.d.ts

@@ -0,0 +1,53 @@
+import type { ConversationMessage, ConversationMode, ConversationStatus, InputDeviceConfig, OutputDeviceConfig, SetVolumeParams, StartSessionOptions } from "./types";
+export declare class Conversation {
+    private readonly options;
+    private readonly room;
+    private connectionDetails;
+    private status;
+    private mode;
+    private readonly messages;
+    private readonly remoteAudioElements;
+    private audioContext;
+    private inputAnalyser;
+    private outputAnalyser;
+    private inputSourceNode;
+    private outputSourceNode;
+    private inputMonitorGain;
+    private outputMonitorGain;
+    private readonly inputFrequencyData;
+    private readonly outputFrequencyData;
+    private isMicMuted;
+    private constructor();
+    static startSession(options: StartSessionOptions): Promise<Conversation>;
+    private start;
+    private fetchConnectionDetails;
+    private bindRoomEvents;
+    private handleTextOnlyTranscription;
+    private attachRemoteAudioTrack;
+    private getOrCreateAudioContext;
+    private setupInputAnalyser;
+    private setupOutputAnalyser;
+    private setupOutputAnalyserFromElement;
+    private setupInputAnalyserFromLocalMicTrack;
+    private pushMessage;
+    private updateStatus;
+    private updateMode;
+    private handleError;
+    private cleanup;
+    endSession(): Promise<void>;
+    getId(): string | undefined;
+    getMessages(): ConversationMessage[];
+    setVolume({ volume }: SetVolumeParams): void;
+    setMicMuted(isMuted: boolean): Promise<void>;
+    sendUserMessage(text: string): Promise<void>;
+    changeInputDevice(config: InputDeviceConfig): Promise<boolean>;
+    changeOutputDevice(config: OutputDeviceConfig): Promise<boolean>;
+    getInputByteFrequencyData(): Uint8Array;
+    getOutputByteFrequencyData(): Uint8Array;
+    getInputVolume(): number;
+    getOutputVolume(): number;
+    getStatus(): ConversationStatus;
+    getMode(): ConversationMode;
+    getMicMuted(): boolean;
+    private isTextOnlySession;
+}

package/dist/conversation.js

@@ -0,0 +1,469 @@
+import { ConnectionState, Room, RoomEvent, Track, } from "livekit-client";
+const LIVEKIT_TOKEN_ENDPOINT = "https://api.tryvox.co/functions/v1/livekit-token";
+const LIVEKIT_CHAT_TOPIC = "lk.chat";
+const LIVEKIT_LEGACY_CHAT_TOPIC = "lk-chat-topic";
+const LIVEKIT_TRANSCRIPTION_TOPIC = "lk.transcription";
+export class Conversation {
+    options;
+    room;
+    connectionDetails = null;
+    status = "disconnected";
+    mode = "listening";
+    messages = new Map();
+    remoteAudioElements = new Set();
+    audioContext = null;
+    inputAnalyser = null;
+    outputAnalyser = null;
+    inputSourceNode = null;
+    outputSourceNode = null;
+    inputMonitorGain = null;
+    outputMonitorGain = null;
+    inputFrequencyData = new Uint8Array(128);
+    outputFrequencyData = new Uint8Array(128);
+    isMicMuted = true;
+    constructor(options) {
+        this.options = options;
+        this.room = new Room();
+    }
+    static async startSession(options) {
+        const conversation = new Conversation(options);
+        await conversation.start();
+        return conversation;
+    }
+    async start() {
+        this.updateStatus("connecting");
+        try {
+            const connectionDetails = await this.fetchConnectionDetails();
+            this.connectionDetails = connectionDetails;
+            this.bindRoomEvents();
+            await this.room.connect(connectionDetails.serverUrl, connectionDetails.participantToken);
+            if (this.isTextOnlySession()) {
+                this.isMicMuted = true;
+            }
+            else {
+                // Voice sessions should start with microphone enabled by default.
+                try {
+                    await this.room.localParticipant.setMicrophoneEnabled(true);
+                    this.isMicMuted = false;
+                    this.setupInputAnalyserFromLocalMicTrack();
+                }
+                catch (error) {
+                    this.isMicMuted = true;
+                    this.handleError(error instanceof Error
+                        ? error
+                        : new Error("Failed to enable microphone"));
+                }
+            }
+            this.updateStatus("connected");
+            this.options.onConnect?.();
+        }
+        catch (error) {
+            this.updateStatus("disconnected");
+            this.handleError(error);
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    async fetchConnectionDetails() {
+        const sourceType = "react-sdk";
+        const sourceVersion = "0.1.0";
+        const mode = this.isTextOnlySession() ? "chat" : "call";
+        const dynamicVariables = this.options.dynamicVariables ?? {};
+        const metadata = this.options.metadata ?? {};
+        const body = {
+            agent_id: this.options.agentId,
+            agent_version: this.options.agentVersion ?? "current",
+            mode,
+            dynamic_variables: dynamicVariables,
+            metadata: {
+                runtime_context: {
+                    source: {
+                        type: sourceType,
+                        version: sourceVersion,
+                    },
+                    mode,
+                },
+                call_web: {
+                    dynamic_variables: dynamicVariables,
+                    metadata,
+                },
+            },
+        };
+        const response = await fetch(LIVEKIT_TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.options.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Session initialization failed (${response.status}): ${text}`);
+        }
+        return (await response.json());
+    }
+    bindRoomEvents() {
+        if (this.isTextOnlySession()) {
+            const handleTextOnlyTranscription = (reader, participantInfo) => {
+                void this.handleTextOnlyTranscription(reader, participantInfo.identity);
+            };
+            this.room.registerTextStreamHandler(LIVEKIT_TRANSCRIPTION_TOPIC, handleTextOnlyTranscription);
+        }
+        this.room.on(RoomEvent.ConnectionStateChanged, (state) => {
+            if (state === ConnectionState.Connected) {
+                this.updateStatus("connected");
+            }
+            if (state === ConnectionState.Disconnected) {
+                this.updateStatus("disconnected");
+            }
+        });
+        this.room.on(RoomEvent.Disconnected, () => {
+            this.cleanup();
+            this.updateStatus("disconnected");
+            this.options.onDisconnect?.();
+        });
+        this.room.on(RoomEvent.ActiveSpeakersChanged, (speakers) => {
+            if (this.isTextOnlySession())
+                return;
+            const hasRemoteSpeaker = speakers.some((speaker) => !speaker.isLocal);
+            this.updateMode(hasRemoteSpeaker ? "speaking" : "listening");
+        });
+        this.room.on(RoomEvent.ChatMessage, (message, participant) => {
+            this.pushMessage({
+                id: message.id,
+                source: participant?.isLocal ? "user" : "agent",
+                text: message.message,
+                timestamp: message.timestamp,
+                isFinal: true,
+            });
+        });
+        this.room.on(RoomEvent.TranscriptionReceived, (segments, participant) => {
+            if (!segments)
+                return;
+            const source = participant?.isLocal ? "user" : "agent";
+            for (const segment of segments) {
+                this.pushMessage({
+                    id: segment.id,
+                    source,
+                    text: segment.text,
+                    timestamp: Date.now(),
+                    isFinal: Boolean(segment.final),
+                });
+            }
+        });
+        this.room.on(RoomEvent.LocalTrackPublished, (publication) => {
+            if (publication.source !== Track.Source.Microphone)
+                return;
+            const track = publication.track;
+            if (!track || !track.mediaStreamTrack)
+                return;
+            this.setupInputAnalyser(track.mediaStreamTrack);
+        });
+        this.room.on(RoomEvent.TrackSubscribed, (track, _publication, participant) => {
+            if (this.isTextOnlySession())
+                return;
+            if (track.kind !== Track.Kind.Audio || participant.isLocal)
+                return;
+            const remoteTrack = track;
+            if (!this.outputAnalyser && remoteTrack.mediaStreamTrack) {
+                this.setupOutputAnalyser(remoteTrack.mediaStreamTrack);
+            }
+            this.attachRemoteAudioTrack(remoteTrack);
+        });
+        this.room.on(RoomEvent.TrackUnsubscribed, (track) => {
+            if (track.kind !== Track.Kind.Audio)
+                return;
+            for (const element of track.detach()) {
+                this.remoteAudioElements.delete(element);
+                if (element.parentNode)
+                    element.parentNode.removeChild(element);
+            }
+        });
+    }
+    async handleTextOnlyTranscription(reader, participantIdentity) {
+        const source = participantIdentity === this.room.localParticipant.identity
+            ? "user"
+            : "agent";
+        const messageId = reader.info.attributes?.["lk.segment_id"] ?? reader.info.id;
+        let latestText = "";
+        if (source === "agent") {
+            this.updateMode("speaking");
+        }
+        try {
+            for await (const text of reader) {
+                latestText = text;
+                this.pushMessage({
+                    id: messageId,
+                    source,
+                    text,
+                    timestamp: reader.info.timestamp,
+                    isFinal: false,
+                });
+            }
+            if (latestText) {
+                this.pushMessage({
+                    id: messageId,
+                    source,
+                    text: latestText,
+                    timestamp: reader.info.timestamp,
+                    isFinal: true,
+                });
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+        finally {
+            if (source === "agent") {
+                this.updateMode("listening");
+            }
+        }
+    }
+    attachRemoteAudioTrack(track) {
+        const attached = track.attach();
+        const elements = Array.isArray(attached) ? attached : [attached];
+        for (const element of elements) {
+            if (!(element instanceof HTMLAudioElement))
+                continue;
+            element.autoplay = true;
+            element.style.display = "none";
+            document.body.appendChild(element);
+            this.remoteAudioElements.add(element);
+            if (!this.outputAnalyser) {
+                this.setupOutputAnalyserFromElement(element);
+            }
+        }
+    }
+    getOrCreateAudioContext() {
+        if (!this.audioContext || this.audioContext.state === "closed") {
+            this.audioContext = new AudioContext();
+        }
+        if (this.audioContext.state === "suspended") {
+            this.audioContext.resume().catch(() => { });
+        }
+        return this.audioContext;
+    }
+    setupInputAnalyser(track) {
+        const context = this.getOrCreateAudioContext();
+        const stream = new MediaStream([track]);
+        const source = context.createMediaStreamSource(stream);
+        const analyser = context.createAnalyser();
+        analyser.fftSize = 256;
+        source.connect(analyser);
+        const silentSink = context.createGain();
+        silentSink.gain.value = 0;
+        analyser.connect(silentSink);
+        silentSink.connect(context.destination);
+        this.inputSourceNode = source;
+        this.inputMonitorGain = silentSink;
+        this.inputAnalyser = analyser;
+    }
+    setupOutputAnalyser(track) {
+        const context = this.getOrCreateAudioContext();
+        const stream = new MediaStream([track]);
+        const source = context.createMediaStreamSource(stream);
+        const analyser = context.createAnalyser();
+        analyser.fftSize = 256;
+        source.connect(analyser);
+        const silentSink = context.createGain();
+        silentSink.gain.value = 0;
+        analyser.connect(silentSink);
+        silentSink.connect(context.destination);
+        this.outputSourceNode = source;
+        this.outputMonitorGain = silentSink;
+        this.outputAnalyser = analyser;
+    }
+    setupOutputAnalyserFromElement(element) {
+        const context = this.getOrCreateAudioContext();
+        const source = context.createMediaElementSource(element);
+        const analyser = context.createAnalyser();
+        analyser.fftSize = 256;
+        source.connect(analyser);
+        source.connect(context.destination);
+        this.outputSourceNode = source;
+        this.outputMonitorGain = null;
+        this.outputAnalyser = analyser;
+    }
+    setupInputAnalyserFromLocalMicTrack() {
+        const publication = this.room.localParticipant.getTrackPublication(Track.Source.Microphone);
+        const track = publication?.track;
+        if (!track || !track.mediaStreamTrack)
+            return;
+        this.setupInputAnalyser(track.mediaStreamTrack);
+    }
+    pushMessage(message) {
+        this.messages.set(message.id, message);
+        this.options.onMessage?.(message);
+    }
+    updateStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.options.onStatusChange?.(status);
+    }
+    updateMode(mode) {
+        if (this.mode === mode)
+            return;
+        this.mode = mode;
+        this.options.onModeChange?.(mode);
+    }
+    handleError(error) {
+        const safeError = error instanceof Error ? error : new Error(String(error));
+        this.options.onError?.(safeError);
+    }
+    cleanup() {
+        this.room.unregisterTextStreamHandler(LIVEKIT_TRANSCRIPTION_TOPIC);
+        for (const element of this.remoteAudioElements) {
+            element.remove();
+        }
+        this.remoteAudioElements.clear();
+        this.inputAnalyser = null;
+        this.outputAnalyser = null;
+        this.inputSourceNode = null;
+        this.outputSourceNode = null;
+        this.inputMonitorGain = null;
+        this.outputMonitorGain = null;
+        if (this.audioContext && this.audioContext.state !== "closed") {
+            this.audioContext.close().catch(() => { });
+        }
+        this.audioContext = null;
+    }
+    async endSession() {
+        if (this.status === "disconnected")
+            return;
+        this.room.disconnect();
+        this.cleanup();
+        this.updateStatus("disconnected");
+    }
+    getId() {
+        return this.connectionDetails?.roomName;
+    }
+    getMessages() {
+        return Array.from(this.messages.values()).sort((a, b) => a.timestamp - b.timestamp);
+    }
+    setVolume({ volume }) {
+        if (this.isTextOnlySession())
+            return;
+        const normalized = Math.max(0, Math.min(1, volume));
+        for (const element of this.remoteAudioElements) {
+            element.volume = normalized;
+        }
+    }
+    async setMicMuted(isMuted) {
+        if (this.isTextOnlySession()) {
+            this.isMicMuted = true;
+            return;
+        }
+        const prev = this.isMicMuted;
+        this.isMicMuted = isMuted;
+        try {
+            await this.room.localParticipant.setMicrophoneEnabled(!isMuted);
+            if (!isMuted) {
+                this.setupInputAnalyserFromLocalMicTrack();
+            }
+        }
+        catch (error) {
+            this.isMicMuted = prev;
+            throw error;
+        }
+    }
+    async sendUserMessage(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        const timestamp = Date.now();
+        const messageId = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+            ? crypto.randomUUID()
+            : `user-${timestamp}`;
+        // Match the prior hook convention: send text stream on lk.chat.
+        if (typeof this.room.localParticipant.sendText === "function") {
+            await this.room.localParticipant.sendText(trimmed, {
+                topic: LIVEKIT_CHAT_TOPIC,
+            });
+            // Compatibility fallback for legacy chat topic consumers.
+            try {
+                const payload = new TextEncoder().encode(JSON.stringify({
+                    id: messageId,
+                    timestamp,
+                    message: trimmed,
+                    ignoreLegacy: true,
+                }));
+                await this.room.localParticipant.publishData(payload, {
+                    reliable: true,
+                    topic: LIVEKIT_LEGACY_CHAT_TOPIC,
+                });
+            }
+            catch {
+                // Non-fatal: stream text path is the primary transport.
+            }
+            this.pushMessage({
+                id: messageId,
+                source: "user",
+                text: trimmed,
+                timestamp,
+                isFinal: true,
+            });
+            return;
+        }
+        if (typeof this.room.localParticipant.sendChatMessage === "function") {
+            await this.room.localParticipant.sendChatMessage(trimmed);
+            return;
+        }
+        // Last-resort local echo when text send APIs are unavailable.
+        this.pushMessage({
+            id: `user-${Date.now()}`,
+            source: "user",
+            text: trimmed,
+            timestamp: Date.now(),
+            isFinal: true,
+        });
+    }
+    async changeInputDevice(config) {
+        if (this.isTextOnlySession())
+            return false;
+        return this.room.switchActiveDevice("audioinput", config.inputDeviceId);
+    }
+    async changeOutputDevice(config) {
+        if (this.isTextOnlySession())
+            return false;
+        return this.room.switchActiveDevice("audiooutput", config.outputDeviceId);
+    }
+    getInputByteFrequencyData() {
+        if (!this.inputAnalyser)
+            return new Uint8Array();
+        this.inputAnalyser.getByteFrequencyData(this.inputFrequencyData);
+        return new Uint8Array(this.inputFrequencyData);
+    }
+    getOutputByteFrequencyData() {
+        if (!this.outputAnalyser)
+            return new Uint8Array();
+        this.outputAnalyser.getByteFrequencyData(this.outputFrequencyData);
+        return new Uint8Array(this.outputFrequencyData);
+    }
+    getInputVolume() {
+        const data = this.getInputByteFrequencyData();
+        if (!data.length)
+            return 0;
+        const peak = Math.max(...data);
+        return peak / 255;
+    }
+    getOutputVolume() {
+        const data = this.getOutputByteFrequencyData();
+        if (!data.length)
+            return 0;
+        const peak = Math.max(...data);
+        return peak / 255;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getMode() {
+        return this.mode;
+    }
+    getMicMuted() {
+        return this.isMicMuted;
+    }
+    isTextOnlySession() {
+        return this.options.textOnly === true;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Conversation } from "./conversation";
+export type { ConversationMessage, ConversationMode, ConversationSource, ConversationStatus, InputDeviceConfig, OutputDeviceConfig, SetVolumeParams, StartSessionOptions, } from "./types";

package/dist/index.js

@@ -0,0 +1 @@
+export { Conversation } from "./conversation";

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export type ConversationStatus = "disconnected" | "connecting" | "connected";
+export type ConversationMode = "listening" | "speaking";
+export type ConversationSource = "agent" | "user" | "system";
+export type ConversationMessage = {
+    id: string;
+    source: ConversationSource;
+    text: string;
+    timestamp: number;
+    isFinal: boolean;
+};
+export type StartSessionOptions = {
+    agentId: string;
+    apiKey: string;
+    agentVersion?: string;
+    textOnly?: boolean;
+    dynamicVariables?: Record<string, string | number | boolean>;
+    metadata?: Record<string, unknown>;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: Error) => void;
+    onMessage?: (message: ConversationMessage) => void;
+    onStatusChange?: (status: ConversationStatus) => void;
+    onModeChange?: (mode: ConversationMode) => void;
+};
+export type SetVolumeParams = {
+    volume: number;
+};
+export type InputDeviceConfig = {
+    inputDeviceId: string;
+};
+export type OutputDeviceConfig = {
+    outputDeviceId: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vox-ai/client",
+  "version": "0.1.0",
+  "description": "vox.ai JavaScript SDK",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "livekit-client": "^2.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  },
+  "license": "MIT"
+}