@speechos/core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1165 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const livekit_client = __toESM(require("livekit-client"));
+
+//#region src/config.ts
+/**
+* Default host - can be overridden by SPEECHOS_HOST env var at build time
+*/
+const DEFAULT_HOST = typeof process !== "undefined" && process.env?.SPEECHOS_HOST || "https://app.speechos.ai";
+/**
+* Default configuration values
+*/
+const defaultConfig = {
+	apiKey: "",
+	userId: "",
+	host: DEFAULT_HOST,
+	position: "bottom-center",
+	zIndex: 999999,
+	debug: false
+};
+/**
+* Validates and merges user config with defaults
+* @param userConfig - User-provided configuration
+* @returns Validated and merged configuration
+*/
+function validateConfig(userConfig = {}) {
+	if (!userConfig.apiKey) throw new Error("SpeechOS requires an apiKey. Get one from your team dashboard at /a/<team-slug>/.");
+	const config = {
+		...defaultConfig,
+		...userConfig
+	};
+	const validPositions = [
+		"bottom-center",
+		"bottom-right",
+		"bottom-left"
+	];
+	if (!validPositions.includes(config.position)) {
+		console.warn(`Invalid position "${config.position}". Using default "bottom-center".`);
+		config.position = "bottom-center";
+	}
+	if (typeof config.zIndex !== "number" || config.zIndex < 0) {
+		console.warn(`Invalid zIndex "${config.zIndex}". Using default ${defaultConfig.zIndex}.`);
+		config.zIndex = defaultConfig.zIndex;
+	}
+	return config;
+}
+/**
+* Current active configuration (singleton)
+*/
+let currentConfig = defaultConfig;
+/**
+* Get the current configuration
+*/
+function getConfig() {
+	return { ...currentConfig };
+}
+/**
+* Set the current configuration
+* @param config - Configuration to set
+*/
+function setConfig(config) {
+	currentConfig = validateConfig(config);
+}
+/**
+* Reset configuration to defaults
+*/
+function resetConfig() {
+	currentConfig = { ...defaultConfig };
+}
+/**
+* Update the userId in the current configuration
+* @param userId - The user identifier to set
+*/
+function updateUserId(userId) {
+	currentConfig = {
+		...currentConfig,
+		userId
+	};
+}
+
+//#endregion
+//#region src/events.ts
+/**
+* Type-safe event emitter for SpeechOS events
+*/
+var SpeechOSEventEmitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	/**
+	* Subscribe to an event
+	* @param event - Event name to listen to
+	* @param callback - Function to call when event is emitted
+	* @returns Unsubscribe function
+	*/
+	on(event, callback) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(callback);
+		return () => {
+			const callbacks = this.listeners.get(event);
+			if (callbacks) {
+				callbacks.delete(callback);
+				if (callbacks.size === 0) this.listeners.delete(event);
+			}
+		};
+	}
+	/**
+	* Subscribe to an event once (automatically unsubscribes after first call)
+	* @param event - Event name to listen to
+	* @param callback - Function to call when event is emitted
+	* @returns Unsubscribe function
+	*/
+	once(event, callback) {
+		const unsubscribe = this.on(event, (payload) => {
+			unsubscribe();
+			callback(payload);
+		});
+		return unsubscribe;
+	}
+	/**
+	* Emit an event to all subscribers
+	* @param event - Event name to emit
+	* @param payload - Event payload data
+	*/
+	emit(event, payload) {
+		const callbacks = this.listeners.get(event);
+		if (callbacks) callbacks.forEach((callback) => {
+			try {
+				callback(payload);
+			} catch (error) {
+				console.error(`Error in event listener for "${String(event)}":`, error);
+			}
+		});
+	}
+	/**
+	* Remove all listeners for a specific event or all events
+	* @param event - Optional event name to clear listeners for
+	*/
+	clear(event) {
+		if (event) this.listeners.delete(event);
+		else this.listeners.clear();
+	}
+	/**
+	* Get the number of listeners for an event
+	* @param event - Event name
+	* @returns Number of listeners
+	*/
+	listenerCount(event) {
+		return this.listeners.get(event)?.size ?? 0;
+	}
+};
+const events = new SpeechOSEventEmitter();
+
+//#endregion
+//#region src/state.ts
+/**
+* Initial state
+*/
+const initialState = {
+	isVisible: false,
+	isExpanded: false,
+	isConnected: false,
+	isMicEnabled: false,
+	activeAction: null,
+	focusedElement: null,
+	recordingState: "idle",
+	errorMessage: null
+};
+/**
+* State manager class
+*/
+var StateManager = class {
+	state;
+	subscribers = /* @__PURE__ */ new Set();
+	constructor(initialState$1) {
+		this.state = { ...initialState$1 };
+	}
+	/**
+	* Get the current state (returns a copy to prevent mutations)
+	*/
+	getState() {
+		return { ...this.state };
+	}
+	/**
+	* Update state with partial values
+	* @param partial - Partial state to merge with current state
+	*/
+	setState(partial) {
+		const prevState = { ...this.state };
+		this.state = {
+			...this.state,
+			...partial
+		};
+		this.subscribers.forEach((callback) => {
+			try {
+				callback(this.state, prevState);
+			} catch (error) {
+				console.error("Error in state change callback:", error);
+			}
+		});
+		events.emit("state:change", { state: this.state });
+	}
+	/**
+	* Subscribe to state changes
+	* @param callback - Function to call when state changes
+	* @returns Unsubscribe function
+	*/
+	subscribe(callback) {
+		this.subscribers.add(callback);
+		return () => {
+			this.subscribers.delete(callback);
+		};
+	}
+	/**
+	* Reset state to initial values
+	*/
+	reset() {
+		this.setState(initialState);
+	}
+	/**
+	* Show the widget
+	*/
+	show() {
+		this.setState({ isVisible: true });
+		events.emit("widget:show", void 0);
+	}
+	/**
+	* Hide the widget and reset expanded state
+	*/
+	hide() {
+		this.setState({
+			isVisible: false,
+			isExpanded: false,
+			activeAction: null
+		});
+		events.emit("widget:hide", void 0);
+	}
+	/**
+	* Toggle the action bubbles expansion
+	*/
+	toggleExpanded() {
+		this.setState({ isExpanded: !this.state.isExpanded });
+	}
+	/**
+	* Set the focused form element
+	* @param element - The form element that has focus
+	*/
+	setFocusedElement(element) {
+		this.setState({ focusedElement: element });
+	}
+	/**
+	* Set the active action
+	* @param action - The action to set as active
+	*/
+	setActiveAction(action) {
+		this.setState({ activeAction: action });
+	}
+	/**
+	* Set the recording state
+	* @param recordingState - The recording state to set
+	*/
+	setRecordingState(recordingState) {
+		this.setState({ recordingState });
+	}
+	/**
+	* Set the connection state
+	* @param isConnected - Whether connected to LiveKit
+	*/
+	setConnected(isConnected) {
+		this.setState({ isConnected });
+	}
+	/**
+	* Set the microphone enabled state
+	* @param isMicEnabled - Whether microphone is enabled
+	*/
+	setMicEnabled(isMicEnabled) {
+		this.setState({ isMicEnabled });
+	}
+	/**
+	* Start recording flow (connecting → recording)
+	*/
+	startRecording() {
+		this.setState({
+			recordingState: "connecting",
+			isExpanded: false
+		});
+	}
+	/**
+	* Stop recording and start processing
+	*/
+	stopRecording() {
+		this.setState({
+			recordingState: "processing",
+			isMicEnabled: false
+		});
+	}
+	/**
+	* Complete the recording flow and return to idle
+	*/
+	completeRecording() {
+		this.setState({
+			recordingState: "idle",
+			activeAction: null,
+			isConnected: false,
+			isMicEnabled: false
+		});
+	}
+	/**
+	* Cancel recording and return to idle
+	*/
+	cancelRecording() {
+		this.setState({
+			recordingState: "idle",
+			activeAction: null,
+			errorMessage: null,
+			isConnected: false,
+			isMicEnabled: false
+		});
+	}
+	/**
+	* Set error state with a message
+	* @param message - Error message to display
+	*/
+	setError(message) {
+		this.setState({
+			recordingState: "error",
+			errorMessage: message
+		});
+	}
+	/**
+	* Clear error state and return to idle
+	*/
+	clearError() {
+		this.setState({
+			recordingState: "idle",
+			errorMessage: null
+		});
+	}
+};
+const state = new StateManager(initialState);
+/**
+* Create a new state manager instance (useful for testing)
+*/
+function createStateManager(initial) {
+	return new StateManager({
+		...initialState,
+		...initial
+	});
+}
+
+//#endregion
+//#region src/livekit.ts
+const MESSAGE_TYPE_REQUEST_TRANSCRIPT = "request_transcript";
+const MESSAGE_TYPE_TRANSCRIPT = "transcript";
+const MESSAGE_TYPE_EDIT_TEXT = "edit_text";
+const MESSAGE_TYPE_EDITED_TEXT = "edited_text";
+const MESSAGE_TYPE_ERROR = "error";
+const TOPIC_SPEECHOS = "speechos";
+/**
+* A deferred promise with timeout support.
+* Encapsulates resolve/reject/timeout in a single object for cleaner async handling.
+*/
+var Deferred = class {
+	promise;
+	_resolve;
+	_reject;
+	_timeoutId = null;
+	_settled = false;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this._resolve = resolve;
+			this._reject = reject;
+		});
+	}
+	/**
+	* Set a timeout that will reject the promise with the given error
+	*/
+	setTimeout(ms, errorMessage, errorCode, errorSource) {
+		this._timeoutId = setTimeout(() => {
+			if (!this._settled) {
+				console.error(`[SpeechOS] Error: ${errorMessage} (${errorCode})`);
+				events.emit("error", {
+					code: errorCode,
+					message: errorMessage,
+					source: errorSource
+				});
+				this.reject(new Error(errorMessage));
+			}
+		}, ms);
+	}
+	resolve(value) {
+		if (!this._settled) {
+			this._settled = true;
+			this.clearTimeout();
+			this._resolve(value);
+		}
+	}
+	reject(error) {
+		if (!this._settled) {
+			this._settled = true;
+			this.clearTimeout();
+			this._reject(error);
+		}
+	}
+	clearTimeout() {
+		if (this._timeoutId !== null) {
+			clearTimeout(this._timeoutId);
+			this._timeoutId = null;
+		}
+	}
+	get isSettled() {
+		return this._settled;
+	}
+};
+/**
+* LiveKit connection manager
+*/
+var LiveKitManager = class {
+	room = null;
+	tokenData = null;
+	micTrack = null;
+	pendingTranscript = null;
+	pendingEditText = null;
+	pendingTrackSubscribed = null;
+	preWarmPromise = null;
+	editOriginalText = null;
+	/**
+	* Pre-warm resources for faster connection
+	* Call this when user shows intent (e.g., expands widget)
+	* Only fetches token - mic permission is requested when user clicks Dictate
+	*/
+	async preWarm() {
+		if (this.tokenData || this.preWarmPromise || this.room?.state === "connected") {
+			const config$1 = getConfig();
+			if (config$1.debug) console.log("[SpeechOS] Pre-warm skipped - token already available");
+			return;
+		}
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Pre-warming: fetching token...");
+		this.preWarmPromise = (async () => {
+			try {
+				await this.fetchToken();
+				if (config.debug) console.log("[SpeechOS] Pre-warm complete - token ready");
+			} catch (error) {
+				if (config.debug) console.warn("[SpeechOS] Pre-warm failed:", error);
+				this.preWarmPromise = null;
+			}
+		})();
+		await this.preWarmPromise;
+	}
+	/**
+	* Fetch a LiveKit token from the backend
+	*/
+	async fetchToken() {
+		const config = getConfig();
+		const url = `${config.host}/livekit/api/token/`;
+		if (config.debug) console.log("[SpeechOS] Fetching LiveKit token from:", url);
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...config.apiKey ? { Authorization: `Api-Key ${config.apiKey}` } : {}
+			},
+			body: JSON.stringify({ user_id: config.userId || null })
+		});
+		if (!response.ok) throw new Error(`Failed to fetch LiveKit token: ${response.status} ${response.statusText}`);
+		const data = await response.json();
+		this.tokenData = data;
+		if (config.debug) console.log("[SpeechOS] LiveKit token received:", {
+			room: data.room,
+			identity: data.identity,
+			ws_url: data.ws_url
+		});
+		return data;
+	}
+	/**
+	* Connect to a LiveKit room (fresh connection each time)
+	*/
+	async connect() {
+		const config = getConfig();
+		if (!this.tokenData) await this.fetchToken();
+		else if (config.debug) console.log("[SpeechOS] Using pre-fetched token");
+		if (!this.tokenData) throw new Error("No token available for LiveKit connection");
+		this.room = new livekit_client.Room({
+			adaptiveStream: true,
+			dynacast: true
+		});
+		this.setupRoomEvents();
+		if (config.debug) console.log("[SpeechOS] Connecting to LiveKit room:", this.tokenData.room);
+		await this.room.connect(this.tokenData.ws_url, this.tokenData.token);
+		state.setConnected(true);
+		if (config.debug) console.log("[SpeechOS] Connected to LiveKit room:", this.room.name);
+		return this.room;
+	}
+	/**
+	* Wait until the agent is ready to receive audio
+	* Resolves when LocalTrackSubscribed event is received
+	*/
+	async waitUntilReady() {
+		if (!this.room || this.room.state !== "connected") throw new Error("Not connected to room");
+		if (this.pendingTrackSubscribed) return this.pendingTrackSubscribed.promise;
+		this.pendingTrackSubscribed = new Deferred();
+		this.pendingTrackSubscribed.setTimeout(15e3, "Connection timed out - agent not available", "connection_timeout", "connection");
+		return this.pendingTrackSubscribed.promise;
+	}
+	/**
+	* Set up LiveKit room event listeners
+	*/
+	setupRoomEvents() {
+		if (!this.room) return;
+		const config = getConfig();
+		this.room.on(livekit_client.RoomEvent.Connected, () => {
+			if (config.debug) console.log("[SpeechOS] Room connected");
+			state.setConnected(true);
+		});
+		this.room.on(livekit_client.RoomEvent.Disconnected, (reason) => {
+			if (config.debug) console.log("[SpeechOS] Room disconnected:", reason);
+			state.setConnected(false);
+			state.setMicEnabled(false);
+		});
+		this.room.on(livekit_client.RoomEvent.ParticipantConnected, (participant) => {
+			if (config.debug) console.log("[SpeechOS] Participant connected:", participant.identity);
+		});
+		this.room.on(livekit_client.RoomEvent.LocalTrackSubscribed, (publication) => {
+			if (config.debug) console.log("[SpeechOS] LocalTrackSubscribed event fired:", publication.trackSid);
+			if (this.pendingTrackSubscribed) {
+				this.pendingTrackSubscribed.resolve();
+				this.pendingTrackSubscribed = null;
+			}
+		});
+		this.room.on(livekit_client.RoomEvent.LocalTrackPublished, (publication) => {
+			if (config.debug) console.log("[SpeechOS] LocalTrackPublished:", publication.trackSid, publication.source);
+		});
+		this.room.on(livekit_client.RoomEvent.DataReceived, (data, participant) => {
+			this.handleDataMessage(data, participant);
+		});
+	}
+	/**
+	* Handle incoming data messages from the agent
+	*/
+	handleDataMessage(data, _participant) {
+		const config = getConfig();
+		try {
+			const message = JSON.parse(new TextDecoder().decode(data));
+			if (config.debug) console.log("[SpeechOS] Data received:", message);
+			if (message.type === MESSAGE_TYPE_TRANSCRIPT) {
+				const transcript = message.transcript || "";
+				if (config.debug) console.log("[SpeechOS] Transcript received:", transcript);
+				events.emit("transcription:complete", { text: transcript });
+				if (this.pendingTranscript) {
+					this.pendingTranscript.resolve(transcript);
+					this.pendingTranscript = null;
+				}
+			} else if (message.type === MESSAGE_TYPE_EDITED_TEXT) {
+				const editedText = message.text || "";
+				if (config.debug) console.log("[SpeechOS] Edited text received:", editedText);
+				events.emit("edit:complete", {
+					text: editedText,
+					originalText: this.editOriginalText || ""
+				});
+				if (this.pendingEditText) {
+					this.pendingEditText.resolve(editedText);
+					this.pendingEditText = null;
+				}
+				this.editOriginalText = null;
+			} else if (message.type === MESSAGE_TYPE_ERROR) {
+				const serverError = message;
+				const errorCode = serverError.code || "server_error";
+				const errorMessage = serverError.message || "A server error occurred";
+				console.error(`[SpeechOS] Error: ${errorMessage} (${errorCode})`);
+				if (config.debug && serverError.details) console.error("[SpeechOS] Error details:", serverError.details);
+				events.emit("error", {
+					code: errorCode,
+					message: errorMessage,
+					source: "server"
+				});
+				const error = new Error(errorMessage);
+				if (this.pendingTranscript) {
+					this.pendingTranscript.reject(error);
+					this.pendingTranscript = null;
+				}
+				if (this.pendingEditText) {
+					this.pendingEditText.reject(error);
+					this.pendingEditText = null;
+				}
+			}
+		} catch (error) {
+			console.error("[SpeechOS] Failed to parse data message:", error);
+		}
+	}
+	/**
+	* Publish microphone audio track
+	*/
+	async enableMicrophone() {
+		if (!this.room || this.room.state !== "connected") throw new Error("Not connected to room");
+		const config = getConfig();
+		if (!this.micTrack) {
+			if (config.debug) console.log("[SpeechOS] Creating microphone track...");
+			this.micTrack = await (0, livekit_client.createLocalAudioTrack)({
+				echoCancellation: true,
+				noiseSuppression: true
+			});
+		}
+		const existingPub = this.room.localParticipant.getTrackPublication(livekit_client.Track.Source.Microphone);
+		if (!existingPub) {
+			await this.room.localParticipant.publishTrack(this.micTrack, { source: livekit_client.Track.Source.Microphone });
+			state.setMicEnabled(true);
+			if (config.debug) console.log("[SpeechOS] Microphone track published");
+		}
+	}
+	/**
+	* Disable microphone audio track
+	*/
+	async disableMicrophone() {
+		const config = getConfig();
+		if (this.micTrack) {
+			if (config.debug) console.log("[SpeechOS] Disabling microphone track...");
+			if (this.room?.state === "connected") try {
+				await this.room.localParticipant.unpublishTrack(this.micTrack);
+				if (config.debug) console.log("[SpeechOS] Microphone track unpublished");
+			} catch (error) {
+				console.warn("[SpeechOS] Error unpublishing track:", error);
+			}
+			this.micTrack.stop();
+			this.micTrack.detach();
+			this.micTrack = null;
+			state.setMicEnabled(false);
+			if (config.debug) console.log("[SpeechOS] Microphone track stopped and detached");
+		}
+	}
+	/**
+	* Send a data message to the room
+	*/
+	async sendDataMessage(message) {
+		if (!this.room || this.room.state !== "connected") throw new Error("Not connected to room");
+		const data = new TextEncoder().encode(JSON.stringify(message));
+		await this.room.localParticipant.publishData(data, {
+			reliable: true,
+			topic: TOPIC_SPEECHOS
+		});
+	}
+	/**
+	* Start a voice session
+	* Connects to room, enables microphone, and waits for agent to subscribe to our track
+	*/
+	async startVoiceSession() {
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Starting voice session...");
+		if (this.preWarmPromise) {
+			if (config.debug) console.log("[SpeechOS] Waiting for pre-warm to complete...");
+			await this.preWarmPromise;
+		}
+		if (this.tokenData) {
+			if (config.debug) console.log("[SpeechOS] Using cached token from init");
+		} else {
+			if (config.debug) console.log("[SpeechOS] Fetching fresh token for session...");
+			await this.fetchToken();
+		}
+		this.pendingTrackSubscribed = new Deferred();
+		this.pendingTrackSubscribed.setTimeout(15e3, "Connection timed out - agent not available", "connection_timeout", "connection");
+		await this.connect();
+		await this.enableMicrophone();
+		if (config.debug) console.log("[SpeechOS] Microphone published, waiting for LocalTrackSubscribed event...");
+		await this.pendingTrackSubscribed.promise;
+		this.pendingTrackSubscribed = null;
+		if (config.debug) console.log("[SpeechOS] Voice session ready - agent subscribed to audio");
+	}
+	/**
+	* Stop the voice session and request the transcript
+	* Returns a promise that resolves with the transcript text
+	* @throws Error if timeout occurs waiting for transcript
+	*/
+	async stopVoiceSession() {
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Stopping voice session, requesting transcript...");
+		await this.disableMicrophone();
+		if (config.debug) console.log("[SpeechOS] Requesting transcript from agent...");
+		this.pendingTranscript = new Deferred();
+		this.pendingTranscript.setTimeout(1e4, "Transcription timed out. Please try again.", "transcription_timeout", "timeout");
+		await this.sendDataMessage({ type: MESSAGE_TYPE_REQUEST_TRANSCRIPT });
+		const result = await this.pendingTranscript.promise;
+		this.pendingTranscript = null;
+		return result;
+	}
+	/**
+	* Alias for stopVoiceSession - granular API naming
+	*/
+	async stopAndGetTranscript() {
+		return this.stopVoiceSession();
+	}
+	/**
+	* Request text editing using the transcript as instructions
+	* Sends the original text to the backend, which applies the spoken instructions
+	* Returns a promise that resolves with the edited text
+	* @throws Error if timeout occurs waiting for edited text
+	*/
+	async requestEditText(originalText) {
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Requesting text edit...");
+		this.editOriginalText = originalText;
+		await this.disableMicrophone();
+		if (config.debug) console.log("[SpeechOS] Sending edit_text request to agent...");
+		this.pendingEditText = new Deferred();
+		this.pendingEditText.setTimeout(15e3, "Edit request timed out. Please try again.", "edit_timeout", "timeout");
+		await this.sendDataMessage({
+			type: MESSAGE_TYPE_EDIT_TEXT,
+			text: originalText
+		});
+		const result = await this.pendingEditText.promise;
+		this.pendingEditText = null;
+		return result;
+	}
+	/**
+	* Alias for requestEditText - granular API naming
+	*/
+	async stopAndEdit(originalText) {
+		return this.requestEditText(originalText);
+	}
+	/**
+	* Disconnect from the current room
+	* Clears the token so a fresh one is fetched for the next session
+	*/
+	async disconnect() {
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Disconnecting from room...");
+		await this.disableMicrophone();
+		if (this.room) {
+			this.room.removeAllListeners();
+			await this.room.disconnect();
+			this.room = null;
+			state.setConnected(false);
+			if (config.debug) console.log("[SpeechOS] Room disconnected and cleaned up");
+		}
+		if (this.pendingTranscript) {
+			this.pendingTranscript.reject(new Error("Disconnected"));
+			this.pendingTranscript = null;
+		}
+		if (this.pendingEditText) {
+			this.pendingEditText.reject(new Error("Disconnected"));
+			this.pendingEditText = null;
+		}
+		if (this.pendingTrackSubscribed) {
+			this.pendingTrackSubscribed.reject(new Error("Disconnected"));
+			this.pendingTrackSubscribed = null;
+		}
+		this.tokenData = null;
+		this.preWarmPromise = null;
+		this.editOriginalText = null;
+		if (config.debug) console.log("[SpeechOS] Session state cleared");
+	}
+	/**
+	* Get the current room instance
+	*/
+	getRoom() {
+		return this.room;
+	}
+	/**
+	* Get the current token data
+	*/
+	getTokenData() {
+		return this.tokenData;
+	}
+	/**
+	* Check if connected to a room
+	*/
+	isConnected() {
+		return this.room?.state === "connected";
+	}
+	/**
+	* Check if microphone is enabled
+	*/
+	isMicrophoneEnabled() {
+		return this.micTrack !== null;
+	}
+	/**
+	* Clear the cached token
+	* Used when user identity changes to ensure next session gets a fresh token
+	*/
+	clearToken() {
+		const config = getConfig();
+		if (config.debug) console.log("[SpeechOS] Clearing cached token");
+		this.tokenData = null;
+		this.preWarmPromise = null;
+	}
+};
+const livekit = new LiveKitManager();
+
+//#endregion
+//#region src/transcript-store.ts
+const STORAGE_KEY = "speechos_transcripts";
+const MAX_ENTRIES = 50;
+/**
+* Generate a unique ID for transcript entries
+*/
+function generateId() {
+	return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Get all transcripts from localStorage
+*/
+function getTranscripts() {
+	try {
+		const stored = localStorage.getItem(STORAGE_KEY);
+		if (!stored) return [];
+		const entries = JSON.parse(stored);
+		return entries.sort((a, b) => b.timestamp - a.timestamp);
+	} catch {
+		return [];
+	}
+}
+/**
+* Save a new transcript entry
+*/
+function saveTranscript(text, action, originalText) {
+	const entry = {
+		id: generateId(),
+		text,
+		timestamp: Date.now(),
+		action,
+		...originalText && { originalText }
+	};
+	const entries = getTranscripts();
+	entries.unshift(entry);
+	const pruned = entries.slice(0, MAX_ENTRIES);
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(pruned));
+	} catch {}
+	return entry;
+}
+/**
+* Clear all transcript history
+*/
+function clearTranscripts() {
+	try {
+		localStorage.removeItem(STORAGE_KEY);
+	} catch {}
+}
+/**
+* Delete a single transcript by ID
+*/
+function deleteTranscript(id) {
+	const entries = getTranscripts().filter((e) => e.id !== id);
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(entries));
+	} catch {}
+}
+const transcriptStore = {
+	getTranscripts,
+	saveTranscript,
+	clearTranscripts,
+	deleteTranscript
+};
+
+//#endregion
+//#region src/speechos.ts
+/**
+* SpeechOS Core SDK
+*
+* Provides two API layers:
+* 1. Low-level API: Granular control over LiveKit connection lifecycle
+* 2. High-level API: One-shot methods for common voice tasks
+*/
+var SpeechOSCore = class {
+	initialized = false;
+	/**
+	* Initialize the SDK with configuration
+	* @param config - Configuration options including apiKey
+	*/
+	init(config) {
+		setConfig(config);
+		this.initialized = true;
+		const currentConfig$1 = getConfig();
+		if (currentConfig$1.debug) console.log("[SpeechOS] Initialized with config:", {
+			host: currentConfig$1.host,
+			position: currentConfig$1.position,
+			debug: currentConfig$1.debug
+		});
+	}
+	/**
+	* Check if the SDK is initialized
+	*/
+	isInitialized() {
+		return this.initialized;
+	}
+	/**
+	* Connect to LiveKit (fetches token, establishes connection)
+	* Call this before other low-level methods
+	*/
+	async connect() {
+		this.ensureInitialized();
+		await livekit.connect();
+	}
+	/**
+	* Wait until the agent is ready to receive audio
+	* Resolves when the agent subscribes to our audio track
+	*/
+	async waitUntilReady() {
+		return livekit.waitUntilReady();
+	}
+	/**
+	* Enable microphone (user is now being recorded)
+	*/
+	async enableMicrophone() {
+		await livekit.enableMicrophone();
+		state.setRecordingState("recording");
+	}
+	/**
+	* Stop recording and get the transcript
+	* @returns The transcribed text
+	*/
+	async stopAndGetTranscript() {
+		state.setRecordingState("processing");
+		try {
+			const transcript = await livekit.stopAndGetTranscript();
+			transcriptStore.saveTranscript(transcript, "dictate");
+			state.completeRecording();
+			return transcript;
+		} catch (error) {
+			state.setError(error instanceof Error ? error.message : "Transcription failed");
+			throw error;
+		}
+	}
+	/**
+	* Stop recording and get edited text
+	* @param originalText - The original text to edit based on voice instructions
+	* @returns The edited text
+	*/
+	async stopAndEdit(originalText) {
+		state.setRecordingState("processing");
+		try {
+			const editedText = await livekit.stopAndEdit(originalText);
+			transcriptStore.saveTranscript(editedText, "edit", originalText);
+			state.completeRecording();
+			return editedText;
+		} catch (error) {
+			state.setError(error instanceof Error ? error.message : "Edit request failed");
+			throw error;
+		}
+	}
+	/**
+	* Disconnect from LiveKit
+	*/
+	async disconnect() {
+		await livekit.disconnect();
+		state.completeRecording();
+	}
+	/**
+	* One-shot dictation: connect, wait for agent, record, and get transcript
+	* Automatically handles the full voice session lifecycle
+	*
+	* @returns The transcribed text
+	*/
+	async dictate() {
+		this.ensureInitialized();
+		state.setActiveAction("dictate");
+		state.startRecording();
+		try {
+			await livekit.startVoiceSession();
+			state.setRecordingState("recording");
+			return new Promise((resolve, reject) => {
+				this._dictateResolve = resolve;
+				this._dictateReject = reject;
+			});
+		} catch (error) {
+			state.setError(error instanceof Error ? error.message : "Failed to start dictation");
+			await this.cleanup();
+			throw error;
+		}
+	}
+	_dictateResolve;
+	_dictateReject;
+	/**
+	* Stop dictation and get the transcript
+	* Call this after dictate() when user stops speaking
+	*/
+	async stopDictation() {
+		state.setRecordingState("processing");
+		try {
+			const transcript = await livekit.stopVoiceSession();
+			transcriptStore.saveTranscript(transcript, "dictate");
+			state.completeRecording();
+			if (this._dictateResolve) {
+				this._dictateResolve(transcript);
+				this._dictateResolve = void 0;
+				this._dictateReject = void 0;
+			}
+			return transcript;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error("Transcription failed");
+			state.setError(err.message);
+			if (this._dictateReject) {
+				this._dictateReject(err);
+				this._dictateResolve = void 0;
+				this._dictateReject = void 0;
+			}
+			throw err;
+		} finally {
+			await this.cleanup();
+		}
+	}
+	/**
+	* One-shot edit: connect, wait for agent, record voice instructions, apply to text
+	* Automatically handles the full voice session lifecycle
+	*
+	* @param originalText - The text to edit
+	* @returns The edited text
+	*/
+	async edit(originalText) {
+		this.ensureInitialized();
+		state.setActiveAction("edit");
+		state.startRecording();
+		this._editOriginalText = originalText;
+		try {
+			await livekit.startVoiceSession();
+			state.setRecordingState("recording");
+			return new Promise((resolve, reject) => {
+				this._editResolve = resolve;
+				this._editReject = reject;
+			});
+		} catch (error) {
+			state.setError(error instanceof Error ? error.message : "Failed to start edit");
+			await this.cleanup();
+			throw error;
+		}
+	}
+	_editOriginalText;
+	_editResolve;
+	_editReject;
+	/**
+	* Stop edit recording and get the edited text
+	* Call this after edit() when user stops speaking
+	*/
+	async stopEdit() {
+		state.setRecordingState("processing");
+		try {
+			const originalText = this._editOriginalText || "";
+			const editedText = await livekit.requestEditText(originalText);
+			transcriptStore.saveTranscript(editedText, "edit", originalText);
+			state.completeRecording();
+			if (this._editResolve) {
+				this._editResolve(editedText);
+				this._editResolve = void 0;
+				this._editReject = void 0;
+			}
+			return editedText;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error("Edit request failed");
+			state.setError(err.message);
+			if (this._editReject) {
+				this._editReject(err);
+				this._editResolve = void 0;
+				this._editReject = void 0;
+			}
+			throw err;
+		} finally {
+			this._editOriginalText = void 0;
+			await this.cleanup();
+		}
+	}
+	/**
+	* Cancel the current operation
+	*/
+	async cancel() {
+		const err = new Error("Operation cancelled");
+		if (this._dictateReject) {
+			this._dictateReject(err);
+			this._dictateResolve = void 0;
+			this._dictateReject = void 0;
+		}
+		if (this._editReject) {
+			this._editReject(err);
+			this._editResolve = void 0;
+			this._editReject = void 0;
+		}
+		this._editOriginalText = void 0;
+		await this.cleanup();
+		state.cancelRecording();
+	}
+	/**
+	* Access the state manager for subscribing to state changes
+	*/
+	get state() {
+		return state;
+	}
+	/**
+	* Access the event emitter for listening to events
+	*/
+	get events() {
+		return events;
+	}
+	/**
+	* Get the current config
+	*/
+	getConfig() {
+		return getConfig();
+	}
+	ensureInitialized() {
+		if (!this.initialized) throw new Error("SpeechOS not initialized. Call speechOS.init({ apiKey: ... }) first.");
+	}
+	async cleanup() {
+		try {
+			await livekit.disconnect();
+		} catch (error) {
+			const config = getConfig();
+			if (config.debug) console.warn("[SpeechOS] Cleanup disconnect error:", error);
+		}
+	}
+	/**
+	* Reset the SDK (useful for testing)
+	*/
+	reset() {
+		this.initialized = false;
+		this._dictateResolve = void 0;
+		this._dictateReject = void 0;
+		this._editResolve = void 0;
+		this._editReject = void 0;
+		this._editOriginalText = void 0;
+		resetConfig();
+		state.reset();
+		events.clear();
+	}
+};
+const speechOS = new SpeechOSCore();
+
+//#endregion
+//#region src/index.ts
+const VERSION = "0.1.0";
+
+//#endregion
+exports.DEFAULT_HOST = DEFAULT_HOST;
+exports.Deferred = Deferred;
+exports.SpeechOSEventEmitter = SpeechOSEventEmitter;
+exports.VERSION = VERSION;
+exports.createStateManager = createStateManager;
+exports.defaultConfig = defaultConfig;
+exports.events = events;
+exports.getConfig = getConfig;
+exports.livekit = livekit;
+exports.resetConfig = resetConfig;
+exports.setConfig = setConfig;
+exports.speechOS = speechOS;
+exports.state = state;
+exports.transcriptStore = transcriptStore;
+exports.updateUserId = updateUserId;
+exports.validateConfig = validateConfig;
+//# sourceMappingURL=index.cjs.map