@neta-art/cohub 1.21.0 → 1.23.0

package/dist/voice-input.js

@@ -0,0 +1,394 @@
+import { s as resolveVoiceInputWebsocketUrl } from "./chunks/environment.js";
+//#region src/voice-input.ts
+const TARGET_SAMPLE_RATE = 16e3;
+const CHUNK_SAMPLES = TARGET_SAMPLE_RATE * 200 / 1e3;
+const DEFAULT_CONNECTION_TIMEOUT_MS = 1e4;
+const DEFAULT_IDLE_CONNECTION_TIMEOUT_MS = 30 * 6e4;
+const WEBSOCKET_OPEN = 1;
+const getDefaultWebSocket = () => {
+	const WebSocketImpl = globalThis.WebSocket;
+	if (!WebSocketImpl) throw new Error("WebSocket is not available in this environment");
+	return WebSocketImpl;
+};
+const getDefaultAudioContext = () => {
+	const context = globalThis;
+	return context.AudioContext ?? context.webkitAudioContext;
+};
+const encodeBase64 = (bytes) => {
+	if (typeof btoa === "function") {
+		let binary = "";
+		for (let i = 0; i < bytes.length; i += 1) binary += String.fromCharCode(bytes[i] ?? 0);
+		return btoa(binary);
+	}
+	const maybeBuffer = globalThis.Buffer;
+	if (maybeBuffer) return maybeBuffer.from(bytes).toString("base64");
+	throw new Error("Base64 encoding is not available in this environment");
+};
+const floatToPcm16 = (samples) => {
+	const buffer = /* @__PURE__ */ new ArrayBuffer(samples.length * 2);
+	const view = new DataView(buffer);
+	for (let i = 0; i < samples.length; i += 1) {
+		const sample = Math.max(-1, Math.min(1, samples[i] ?? 0));
+		view.setInt16(i * 2, sample < 0 ? sample * 32768 : sample * 32767, true);
+	}
+	return new Uint8Array(buffer);
+};
+const resampleTo16k = (input, inputSampleRate) => {
+	if (inputSampleRate === TARGET_SAMPLE_RATE) return input;
+	const ratio = inputSampleRate / TARGET_SAMPLE_RATE;
+	const length = Math.floor(input.length / ratio);
+	const output = new Float32Array(length);
+	for (let i = 0; i < length; i += 1) {
+		const index = i * ratio;
+		const left = Math.floor(index);
+		const right = Math.min(left + 1, input.length - 1);
+		const weight = index - left;
+		output[i] = (input[left] ?? 0) * (1 - weight) + (input[right] ?? 0) * weight;
+	}
+	return output;
+};
+const getErrorCode = (event) => {
+	const code = event.payload?.code;
+	return typeof code === "string" ? code : null;
+};
+const getErrorMessage = (event) => {
+	const message = event.payload?.message;
+	return typeof message === "string" ? message : "Voice input failed";
+};
+var VoiceInputClient = class {
+	url;
+	getAccessToken;
+	WebSocketImpl;
+	connectionTimeoutMs;
+	idleConnectionTimeoutMs;
+	callbacks;
+	socket = null;
+	stream = null;
+	audioContext = null;
+	processor = null;
+	source = null;
+	pendingSamples = [];
+	pendingAudio = [];
+	started = false;
+	asrStarted = false;
+	authenticated = false;
+	intentionalClose = false;
+	startPromise = null;
+	socketOpenPromise = null;
+	idleCloseTimer = null;
+	authWaiter = null;
+	asrStartWaiter = null;
+	constructor(options = {}) {
+		this.url = resolveVoiceInputWebsocketUrl({
+			env: options.env,
+			url: options.url
+		});
+		this.getAccessToken = options.getAccessToken;
+		this.WebSocketImpl = options.WebSocketImpl ?? getDefaultWebSocket();
+		this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+		this.idleConnectionTimeoutMs = options.idleConnectionTimeoutMs ?? DEFAULT_IDLE_CONNECTION_TIMEOUT_MS;
+		this.callbacks = options.callbacks ?? {};
+	}
+	async start() {
+		if (this.startPromise) return this.startPromise;
+		if (this.started) return;
+		this.startPromise = this.startInternal().finally(() => {
+			this.startPromise = null;
+		});
+		return this.startPromise;
+	}
+	stop() {
+		if (this.pendingSamples.length > 0) this.sendAudio(new Float32Array(this.pendingSamples.splice(0)));
+		this.flushPendingAudio();
+		if (this.asrStarted) this.send({ type: "asr.stop" });
+		this.cleanupAudio();
+		this.started = false;
+		this.scheduleIdleClose();
+	}
+	cancel() {
+		if (this.asrStarted) this.send({ type: "asr.cancel" });
+		this.cleanupAudio();
+		this.started = false;
+		this.scheduleIdleClose();
+	}
+	close() {
+		this.intentionalClose = true;
+		this.clearIdleCloseTimer();
+		this.cleanupAudio();
+		this.closeSocket();
+		this.started = false;
+	}
+	async startInternal() {
+		this.clearIdleCloseTimer();
+		this.started = true;
+		this.asrStarted = false;
+		this.pendingAudio = [];
+		this.intentionalClose = false;
+		try {
+			await this.withConnectionTimeout(Promise.all([this.setupAudio(), this.ensureAuthenticatedSocket()]));
+			await this.withConnectionTimeout(this.startAsrSession());
+		} catch (error) {
+			this.cleanupAudio();
+			this.started = false;
+			this.scheduleIdleClose();
+			throw error;
+		}
+	}
+	async withConnectionTimeout(promise) {
+		let timeout = null;
+		try {
+			return await Promise.race([promise, new Promise((_, reject) => {
+				timeout = globalThis.setTimeout(() => reject(/* @__PURE__ */ new Error("Voice connection timed out")), this.connectionTimeoutMs);
+			})]);
+		} finally {
+			if (timeout) globalThis.clearTimeout(timeout);
+		}
+	}
+	async ensureAuthenticatedSocket() {
+		if (this.socket?.readyState === WEBSOCKET_OPEN && this.authenticated) return;
+		await this.ensureSocketOpen();
+		if (this.authenticated) return;
+		try {
+			await this.authenticate(false);
+		} catch (error) {
+			if (!(error instanceof Error) || error.message !== "UNAUTHORIZED") throw error;
+			await this.authenticate(true);
+		}
+	}
+	async ensureSocketOpen() {
+		if (this.socket?.readyState === WEBSOCKET_OPEN) return;
+		if (this.socketOpenPromise) return this.socketOpenPromise;
+		this.authenticated = false;
+		this.intentionalClose = false;
+		this.socket = new this.WebSocketImpl(this.url);
+		this.socketOpenPromise = new Promise((resolve, reject) => {
+			const socket = this.socket;
+			if (!socket) return reject(/* @__PURE__ */ new Error("Voice service unavailable"));
+			socket.onopen = () => resolve();
+			socket.onerror = () => reject(/* @__PURE__ */ new Error("Voice service unavailable"));
+			socket.onclose = (event) => {
+				this.authenticated = false;
+				this.socketOpenPromise = null;
+				this.rejectAuthWaiter(/* @__PURE__ */ new Error("Voice connection closed"));
+				this.rejectAsrStartWaiter(/* @__PURE__ */ new Error("Voice connection closed"));
+				if (this.socket === socket) this.socket = null;
+				if (!this.intentionalClose && this.started) {
+					this.cleanupAudio();
+					this.started = false;
+					this.callbacks.onError?.("Voice connection closed. Try again.");
+					this.callbacks.onDone?.();
+				}
+				if (socket.readyState !== WEBSOCKET_OPEN) reject(new Error(event.reason || "Voice connection closed"));
+			};
+			socket.onmessage = (event) => {
+				try {
+					this.handleMessage(event);
+				} catch {
+					this.closeWithError("Voice service sent invalid data. Try again.");
+				}
+			};
+		}).finally(() => {
+			this.socketOpenPromise = null;
+		});
+		return this.socketOpenPromise;
+	}
+	async authenticate(forceRefresh) {
+		const token = await this.getAccessToken?.({ forceRefresh });
+		if (!token) throw new Error("Sign in to use voice input");
+		const waiter = this.createAuthWaiter();
+		this.send({
+			type: "auth",
+			payload: { token }
+		});
+		await waiter.promise;
+	}
+	async startAsrSession() {
+		const waiter = this.createAsrStartWaiter();
+		this.send({ type: "asr.start" });
+		await waiter.promise;
+	}
+	createAuthWaiter() {
+		this.rejectAuthWaiter(/* @__PURE__ */ new Error("superseded auth waiter"));
+		let resolve;
+		let reject;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		this.authWaiter = {
+			promise,
+			resolve,
+			reject
+		};
+		return this.authWaiter;
+	}
+	resolveAuthWaiter() {
+		if (!this.authWaiter) return;
+		this.authWaiter.resolve();
+		this.authWaiter = null;
+	}
+	rejectAuthWaiter(error) {
+		if (!this.authWaiter) return;
+		this.authWaiter.reject(error);
+		this.authWaiter = null;
+	}
+	createAsrStartWaiter() {
+		this.rejectAsrStartWaiter(/* @__PURE__ */ new Error("superseded asr start waiter"));
+		let resolve;
+		let reject;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		this.asrStartWaiter = {
+			promise,
+			resolve,
+			reject
+		};
+		return this.asrStartWaiter;
+	}
+	resolveAsrStartWaiter() {
+		if (!this.asrStartWaiter) return;
+		this.asrStartWaiter.resolve();
+		this.asrStartWaiter = null;
+	}
+	rejectAsrStartWaiter(error) {
+		if (!this.asrStartWaiter) return;
+		this.asrStartWaiter.reject(error);
+		this.asrStartWaiter = null;
+	}
+	closeWithError(message) {
+		this.callbacks.onError?.(message);
+		this.close();
+		this.callbacks.onDone?.();
+	}
+	async setupAudio() {
+		const mediaDevices = globalThis.navigator?.mediaDevices;
+		if (!mediaDevices) throw new Error("Microphone input is not available in this environment");
+		const AudioContextImpl = getDefaultAudioContext();
+		if (!AudioContextImpl) throw new Error("AudioContext is not available in this environment");
+		this.stream = await mediaDevices.getUserMedia({ audio: true });
+		this.audioContext = new AudioContextImpl();
+		await this.audioContext.resume().catch(() => void 0);
+		this.source = this.audioContext.createMediaStreamSource(this.stream);
+		this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+		this.processor.onaudioprocess = (event) => {
+			const resampled = resampleTo16k(event.inputBuffer.getChannelData(0), this.audioContext?.sampleRate ?? TARGET_SAMPLE_RATE);
+			for (const sample of resampled) this.pendingSamples.push(sample);
+			while (this.pendingSamples.length >= CHUNK_SAMPLES) {
+				const chunk = this.pendingSamples.splice(0, CHUNK_SAMPLES);
+				this.sendAudio(new Float32Array(chunk));
+			}
+		};
+		this.source.connect(this.processor);
+		this.processor.connect(this.audioContext.destination);
+	}
+	sendAudio(samples) {
+		const audio = encodeBase64(floatToPcm16(samples));
+		if (!this.asrStarted) {
+			this.pendingAudio.push(audio);
+			return;
+		}
+		this.send({
+			type: "asr.audio",
+			payload: { audio }
+		});
+	}
+	flushPendingAudio() {
+		if (!this.asrStarted) return;
+		for (const audio of this.pendingAudio.splice(0)) this.send({
+			type: "asr.audio",
+			payload: { audio }
+		});
+	}
+	send(message) {
+		if (this.socket?.readyState === WEBSOCKET_OPEN) this.socket.send(JSON.stringify(message));
+	}
+	handleMessage(event) {
+		const data = JSON.parse(String(event.data));
+		const text = typeof data.payload?.text === "string" ? data.payload.text : "";
+		if (data.type === "system.auth.ok") {
+			this.authenticated = true;
+			this.resolveAuthWaiter();
+			return data;
+		}
+		if (data.type === "asr.started") {
+			this.asrStarted = true;
+			this.flushPendingAudio();
+			this.resolveAsrStartWaiter();
+			return data;
+		}
+		if (data.type === "asr.error") {
+			const message = getErrorMessage(data);
+			if (getErrorCode(data) === "UNAUTHORIZED") {
+				this.authenticated = false;
+				this.rejectAuthWaiter(/* @__PURE__ */ new Error("UNAUTHORIZED"));
+			}
+			this.rejectAsrStartWaiter(new Error(message));
+			this.callbacks.onError?.(message);
+			return data;
+		}
+		if (data.type === "asr.partial") this.callbacks.onPartial?.(text);
+		if (data.type === "asr.final") this.callbacks.onFinal?.(text);
+		if (data.type === "asr.done") {
+			this.asrStarted = false;
+			this.started = false;
+			this.scheduleIdleClose();
+			this.callbacks.onDone?.();
+		}
+		return data;
+	}
+	cleanupAudio() {
+		this.processor?.disconnect();
+		if (this.processor) this.processor.onaudioprocess = null;
+		this.source?.disconnect();
+		this.stream?.getTracks().forEach((track) => {
+			track.stop();
+		});
+		this.audioContext?.close().catch(() => void 0);
+		this.processor = null;
+		this.source = null;
+		this.stream = null;
+		this.audioContext = null;
+		this.pendingSamples = [];
+		this.pendingAudio = [];
+		this.asrStarted = false;
+	}
+	scheduleIdleClose() {
+		this.clearIdleCloseTimer();
+		if (!this.socket || this.idleConnectionTimeoutMs <= 0) return;
+		this.idleCloseTimer = globalThis.setTimeout(() => {
+			this.intentionalClose = true;
+			this.closeSocket();
+		}, this.idleConnectionTimeoutMs);
+	}
+	clearIdleCloseTimer() {
+		if (!this.idleCloseTimer) return;
+		globalThis.clearTimeout(this.idleCloseTimer);
+		this.idleCloseTimer = null;
+	}
+	closeSocket() {
+		this.rejectAuthWaiter(/* @__PURE__ */ new Error("Voice connection closed"));
+		this.rejectAsrStartWaiter(/* @__PURE__ */ new Error("Voice connection closed"));
+		this.authenticated = false;
+		this.socketOpenPromise = null;
+		this.socket?.close();
+		this.socket = null;
+	}
+};
+var VoiceApi = class {
+	defaults;
+	constructor(defaults = {}) {
+		this.defaults = defaults;
+	}
+	createInputClient(callbacks = {}, options = {}) {
+		return new VoiceInputClient({
+			...this.defaults,
+			...options,
+			callbacks
+		});
+	}
+};
+const createVoiceInputClient = (options) => new VoiceInputClient(options);
+//#endregion
+export { VoiceApi, VoiceInputClient, createVoiceInputClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "description": "Cohub SDK for spaces, sessions, checkpoints, and realtime agent collaboration.",
   "license": "UNLICENSED",
   "private": false,
@@ -37,6 +37,10 @@
       "types": "./dist/websocket.d.ts",
       "import": "./dist/websocket.js"
     },
+    "./voice-input": {
+      "types": "./dist/voice-input.d.ts",
+      "import": "./dist/voice-input.js"
+    },
     "./debugger": {
       "types": "./dist/debugger.d.ts",
       "import": "./dist/debugger.js"