vsip-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VSIP
+
+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,70 @@
+# vsip-sdk
+
+JavaScript / TypeScript SDK for the VSIP Voice Events API — real-time turn
+detection, identity-gated barge-in, and speaker verification. Runs in the
+browser and Node 18+.
+
+```bash
+npm install vsip-sdk
+```
+
+## Browser quickstart
+
+```ts
+import { VSIPClient, VoiceSession, type Turn } from "vsip-sdk";
+
+const client = new VSIPClient({
+  apiKey: "vsip_...",              // browser: sent as ?token= (proxy in prod)
+  url: "wss://api.vsip.io/v1/stream",
+});
+
+const session = new VoiceSession(client, {
+  onTurn: async (turn: Turn) => {
+    if (!turn.shouldRespond) return;          // verified: not your enrolled user
+    const text = await myStt(turn.audio);     // Int16Array PCM
+    const reply = await myLlm(text);
+    await session.speakGate();                // don't talk over a turn
+    client.agentSpeaking();
+    await myTtsPlay(reply);                    // stop this in onBargeIn
+    client.agentIdle();
+  },
+  onBargeIn: () => myTtsStop(),
+});
+
+await client.connect();
+session.start();
+
+// Feed 16kHz mono Int16 PCM frames from the Web Audio API:
+scriptProcessor.onaudioprocess = (e) => {
+  const f32 = e.inputBuffer.getChannelData(0);
+  const i16 = new Int16Array(f32.length);
+  for (let i = 0; i < f32.length; i++) i16[i] = Math.max(-1, Math.min(1, f32[i])) * 0x7fff;
+  session.sendAudio(i16);
+};
+```
+
+## What `VoiceSession` handles for you
+
+Same field-learned patterns as the Python SDK: onset-lookback turn slicing
+(1.0s / 1.5s for barge-ins), pre-lock fast path + **post-lock
+`speaker_verification` gating** (turns held until the verdict, so an impostor
+is never answered), `speakGate()`, queued turn dispatch, and a capped idle
+buffer. Gate your agent on `turn.shouldRespond`.
+
+`VSIPClient` alone gives you the typed event stream (`client.on(handler)`),
+control commands (`agentSpeaking`/`agentIdle`, `setBargeInMode`, `toggleLock`,
+`reset`), and transparent reconnect + resume.
+
+## Node usage
+
+Node 22 has a global `WebSocket`. On Node 18–20, pass one:
+
+```ts
+import WebSocket from "ws";
+const client = new VSIPClient({ apiKey, url, webSocketImpl: WebSocket as never });
+```
+
+## Types & compatibility
+
+Fully typed (discriminated `VSIPEvent` union). Unknown event types and fields
+parse without error, so this SDK survives additive protocol growth.

package/dist/client.d.ts

@@ -0,0 +1,50 @@
+/**
+ * VSIPClient — WebSocket client for the VSIP Voice Events API.
+ * Browser (native WebSocket) and Node 18+ (global WebSocket / injected impl).
+ */
+import { type SessionStart, type VSIPEvent } from "./events.js";
+export type EventHandler = (event: VSIPEvent) => void;
+export interface VSIPClientOptions {
+    apiKey: string;
+    url?: string;
+    audioFormat?: "int16" | "float32" | "mulaw8k";
+    mode?: "full" | "sidecar";
+    aec?: "client" | "server";
+    tickMs?: number;
+    sessionId?: string;
+    resumable?: boolean;
+    reconnect?: boolean;
+    maxReconnectAttempts?: number;
+    /** Inject a WebSocket implementation (e.g. `ws` on Node < 22). */
+    webSocketImpl?: typeof WebSocket;
+}
+export declare class VSIPError extends Error {
+    closeCode?: number | undefined;
+    constructor(message: string, closeCode?: number | undefined);
+}
+export declare class VSIPClient {
+    streamId: string | null;
+    session: SessionStart | null;
+    private ws;
+    private readonly opts;
+    private readonly handlers;
+    private closed;
+    private readonly WS;
+    constructor(options: VSIPClientOptions);
+    /** Register a handler for every event. Returns an unsubscribe fn. */
+    on(handler: EventHandler): () => void;
+    connect(): Promise<SessionStart>;
+    private buildUrl;
+    private dial;
+    private attachHandlers;
+    private onClose;
+    private emitLocal;
+    sendAudio(frame: ArrayBuffer | ArrayBufferView): void;
+    private sendCommand;
+    agentSpeaking(): void;
+    agentIdle(): void;
+    setBargeInMode(mode: string): void;
+    toggleLock(): void;
+    reset(): void;
+    close(): void;
+}

package/dist/client.js

@@ -0,0 +1,163 @@
+/**
+ * VSIPClient — WebSocket client for the VSIP Voice Events API.
+ * Browser (native WebSocket) and Node 18+ (global WebSocket / injected impl).
+ */
+import { parseEvent } from "./events.js";
+const FATAL_CLOSE_CODES = new Set([4001, 4002, 4004, 4029]);
+export class VSIPError extends Error {
+    constructor(message, closeCode) {
+        super(message);
+        this.closeCode = closeCode;
+        this.name = "VSIPError";
+    }
+}
+export class VSIPClient {
+    constructor(options) {
+        this.streamId = null;
+        this.session = null;
+        this.ws = null;
+        this.handlers = new Set();
+        this.closed = false;
+        this.opts = {
+            url: "wss://api.vsip.io/v1/stream",
+            audioFormat: "int16",
+            mode: "full",
+            aec: "client",
+            tickMs: 80,
+            resumable: true,
+            reconnect: true,
+            maxReconnectAttempts: 5,
+            ...options,
+        };
+        const impl = options.webSocketImpl ?? globalThis.WebSocket;
+        if (!impl) {
+            throw new VSIPError("No WebSocket implementation found. In Node <22 pass webSocketImpl (e.g. from the 'ws' package).");
+        }
+        this.WS = impl;
+    }
+    /** Register a handler for every event. Returns an unsubscribe fn. */
+    on(handler) {
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+    async connect() {
+        await this.dial(null);
+        return this.session;
+    }
+    buildUrl(resumeId) {
+        const p = new URLSearchParams({
+            audio_format: this.opts.audioFormat,
+            mode: this.opts.mode,
+            aec: this.opts.aec,
+            tick_ms: String(this.opts.tickMs),
+            resumable: this.opts.resumable ? "true" : "false",
+        });
+        if (this.opts.sessionId)
+            p.set("session_id", this.opts.sessionId);
+        if (resumeId)
+            p.set("resume", resumeId);
+        // Browsers can't set headers on the WS handshake — the token query param
+        // is the server's documented browser fallback.
+        p.set("token", this.opts.apiKey);
+        return `${this.opts.url}?${p.toString()}`;
+    }
+    dial(resumeId) {
+        return new Promise((resolve, reject) => {
+            const ws = new this.WS(this.buildUrl(resumeId));
+            ws.binaryType = "arraybuffer";
+            this.ws = ws;
+            const onFirst = (ev) => {
+                try {
+                    const payload = JSON.parse(ev.data);
+                    if (payload.type !== "session_start") {
+                        reject(new VSIPError(`expected session_start, got ${payload.type}`));
+                        return;
+                    }
+                    this.session = parseEvent(payload);
+                    this.streamId = this.session.stream_id;
+                    ws.removeEventListener("message", onFirst);
+                    this.attachHandlers(ws);
+                    resolve();
+                }
+                catch (e) {
+                    reject(new VSIPError(`bad session_start: ${String(e)}`));
+                }
+            };
+            ws.addEventListener("message", onFirst);
+            ws.addEventListener("error", () => reject(new VSIPError("WebSocket connection failed")));
+        });
+    }
+    attachHandlers(ws) {
+        ws.addEventListener("message", (ev) => {
+            if (typeof ev.data !== "string")
+                return;
+            let payload;
+            try {
+                payload = JSON.parse(ev.data);
+            }
+            catch {
+                return;
+            }
+            const event = parseEvent(payload);
+            for (const h of this.handlers)
+                h(event);
+        });
+        ws.addEventListener("close", (ev) => this.onClose(ev));
+    }
+    async onClose(ev) {
+        if (this.closed)
+            return;
+        if (FATAL_CLOSE_CODES.has(ev.code)) {
+            this.emitLocal({ type: "error", message: `closed ${ev.code}`, raw: {} });
+            return;
+        }
+        if (!(this.opts.reconnect && this.opts.resumable && this.streamId))
+            return;
+        for (let attempt = 1; attempt <= this.opts.maxReconnectAttempts; attempt++) {
+            await new Promise((r) => setTimeout(r, Math.min(2 ** attempt, 10) * 1000));
+            if (this.closed)
+                return;
+            try {
+                await this.dial(this.streamId);
+                return;
+            }
+            catch {
+                /* retry */
+            }
+        }
+    }
+    emitLocal(event) {
+        for (const h of this.handlers)
+            h(event);
+    }
+    // ── Sending ──────────────────────────────────────────────────────────────
+    sendAudio(frame) {
+        if (this.ws && this.ws.readyState === this.WS.OPEN)
+            this.ws.send(frame);
+    }
+    sendCommand(command, fields = {}) {
+        if (this.ws && this.ws.readyState === this.WS.OPEN) {
+            this.ws.send(JSON.stringify({ command, ...fields }));
+        }
+    }
+    agentSpeaking() {
+        this.sendCommand("set_agent_state", { value: "speaking" });
+    }
+    agentIdle() {
+        this.sendCommand("set_agent_state", { value: "idle" });
+    }
+    setBargeInMode(mode) {
+        this.sendCommand("set_barge_in_mode", { mode });
+    }
+    toggleLock() {
+        this.sendCommand("toggle_lock");
+    }
+    reset() {
+        this.sendCommand("reset");
+    }
+    close() {
+        this.closed = true;
+        this.ws?.close();
+        this.ws = null;
+    }
+}

package/dist/events.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Typed VSIP events (schema_version 1.0). Parsing is tolerant: unknown types
+ * become `{ type, ...raw }` and unknown fields are preserved, so a pinned SDK
+ * keeps working as the additive-only protocol grows.
+ */
+export interface BaseEvent {
+    type: string;
+    timestamp?: number;
+    /** the complete wire payload, always present */
+    raw: Record<string, unknown>;
+}
+export interface SessionStart extends BaseEvent {
+    type: "session_start";
+    stream_id: string;
+    session_id: string;
+    plan_tier: string;
+    tick_ms: number;
+    mode: string;
+    resumed: boolean;
+}
+export interface SessionEnd extends BaseEvent {
+    type: "session_end";
+    stream_id: string;
+    duration_s: number;
+    billed_minutes: number;
+}
+export interface TurnStart extends BaseEvent {
+    type: "turn_start";
+    speaker_id: string;
+    audio_start: number;
+    interrupted_agent: boolean;
+}
+export interface TurnEnd extends BaseEvent {
+    type: "turn_end";
+    speaker_id: string;
+    audio_start: number;
+    duration_ms: number;
+    endpoint: string;
+    endpoint_prob: number | null;
+    interrupted_agent: boolean;
+}
+export interface BargeIn extends BaseEvent {
+    type: "barge_in";
+    speaker_id: string;
+    confidence: number;
+    vad: number;
+}
+export interface SpeakerVerification extends BaseEvent {
+    type: "speaker_verification";
+    speaker_id: string;
+    should_respond: boolean;
+    similarity: number | null;
+    audio_start: number;
+    interrupted_agent: boolean;
+}
+export interface SpeakerChange extends BaseEvent {
+    type: "speaker_change";
+    from: string;
+    to: string;
+    similarity: number;
+}
+export interface NoiseEvent extends BaseEvent {
+    type: "noise_event";
+    class: string;
+    confidence: number;
+}
+export interface LockStatus extends BaseEvent {
+    type: "lock_status";
+    status: string;
+    auto: boolean;
+}
+export interface Telemetry extends BaseEvent {
+    type: "telemetry";
+    vad: number;
+    speaker_id: string;
+    state: string;
+    noise_class: string;
+}
+export interface EnrollmentResult extends BaseEvent {
+    type: "enrollment_result";
+    success: boolean;
+    label: string;
+}
+export interface ErrorEvent extends BaseEvent {
+    type: "error";
+    message: string;
+}
+export type VSIPEvent = SessionStart | SessionEnd | TurnStart | TurnEnd | BargeIn | SpeakerVerification | SpeakerChange | NoiseEvent | LockStatus | Telemetry | EnrollmentResult | ErrorEvent | (BaseEvent & {
+    type: string;
+});
+export declare function parseEvent(payload: Record<string, unknown>): VSIPEvent;
+/** Helper: is a lock_status locked, and to whom? */
+export declare function lockedSpeaker(e: LockStatus): string | null;

package/dist/events.js

@@ -0,0 +1,14 @@
+/**
+ * Typed VSIP events (schema_version 1.0). Parsing is tolerant: unknown types
+ * become `{ type, ...raw }` and unknown fields are preserved, so a pinned SDK
+ * keeps working as the additive-only protocol grows.
+ */
+export function parseEvent(payload) {
+    return { ...payload, type: String(payload.type ?? "unknown"), raw: payload };
+}
+/** Helper: is a lock_status locked, and to whom? */
+export function lockedSpeaker(e) {
+    return e.status.startsWith("locked") && e.status.includes(":")
+        ? e.status.split(":", 2)[1]
+        : null;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { VSIPClient, VSIPError } from "./client.js";
+export type { VSIPClientOptions, EventHandler } from "./client.js";
+export { VoiceSession } from "./session.js";
+export type { Turn, VoiceSessionOptions } from "./session.js";
+export { parseEvent, lockedSpeaker } from "./events.js";
+export type { VSIPEvent, BaseEvent, SessionStart, SessionEnd, TurnStart, TurnEnd, BargeIn, SpeakerVerification, SpeakerChange, NoiseEvent, LockStatus, Telemetry, EnrollmentResult, ErrorEvent, } from "./events.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { VSIPClient, VSIPError } from "./client.js";
+export { VoiceSession } from "./session.js";
+export { parseEvent, lockedSpeaker } from "./events.js";

package/dist/session.d.ts

@@ -0,0 +1,57 @@
+/**
+ * VoiceSession — the recommended integration layer for the JS SDK. Mirrors the
+ * Python VoiceSession: onset-lookback turn slicing, pre-lock fast path +
+ * post-lock speaker_verification gating, queued turn dispatch, capped idle
+ * buffer. Audio is int16 PCM (the browser default).
+ */
+import { VSIPClient } from "./client.js";
+import type { BargeIn, VSIPEvent } from "./events.js";
+export interface Turn {
+    /** int16 PCM samples for the turn, including onset lookback */
+    audio: Int16Array;
+    sampleRate: number;
+    speakerId: string;
+    shouldRespond: boolean;
+    verified: boolean;
+    similarity: number | null;
+    interruptedAgent: boolean;
+    durationMs: number;
+    endpoint: string;
+}
+export interface VoiceSessionOptions {
+    onTurn?: (turn: Turn) => void | Promise<void>;
+    onBargeIn?: (e: BargeIn) => void;
+    onEvent?: (e: VSIPEvent) => void;
+    verifyTimeoutMs?: number;
+    lookbackS?: number;
+    bargeInLookbackS?: number;
+    idleBufferCapS?: number;
+    postTurnKeepS?: number;
+    autoAgentIdleOnBargeIn?: boolean;
+    sampleRate?: number;
+}
+export declare class VoiceSession {
+    private readonly client;
+    private readonly o;
+    private chunks;
+    private totalSamples;
+    private inTurn;
+    private turnSliceStart;
+    private locked;
+    private pending;
+    private queue;
+    private unsub;
+    constructor(client: VSIPClient, options?: VoiceSessionOptions);
+    start(): void;
+    stop(): void;
+    /** Feed one int16 PCM frame: buffered locally for turn slicing AND streamed. */
+    sendAudio(frame: Int16Array): void;
+    /** Resolves once no user turn is open (don't talk over the caller). */
+    speakGate(pollMs?: number): Promise<void>;
+    private absStart;
+    private sliceFrom;
+    private trimToLast;
+    private handle;
+    private dispatch;
+    private dispatchRaw;
+}

package/dist/session.js

@@ -0,0 +1,179 @@
+/**
+ * VoiceSession — the recommended integration layer for the JS SDK. Mirrors the
+ * Python VoiceSession: onset-lookback turn slicing, pre-lock fast path +
+ * post-lock speaker_verification gating, queued turn dispatch, capped idle
+ * buffer. Audio is int16 PCM (the browser default).
+ */
+const VERIFY_MATCH_TOLERANCE_S = 1.5;
+export class VoiceSession {
+    constructor(client, options = {}) {
+        this.chunks = [];
+        this.totalSamples = 0;
+        this.inTurn = false;
+        this.turnSliceStart = 0;
+        this.locked = false;
+        this.pending = null;
+        this.queue = Promise.resolve();
+        this.unsub = null;
+        this.client = client;
+        this.o = {
+            onTurn: options.onTurn ?? (() => { }),
+            onBargeIn: options.onBargeIn ?? (() => { }),
+            onEvent: options.onEvent ?? (() => { }),
+            verifyTimeoutMs: options.verifyTimeoutMs ?? 12000,
+            lookbackS: options.lookbackS ?? 1.0,
+            bargeInLookbackS: options.bargeInLookbackS ?? 1.5,
+            idleBufferCapS: options.idleBufferCapS ?? 35,
+            postTurnKeepS: options.postTurnKeepS ?? 2,
+            autoAgentIdleOnBargeIn: options.autoAgentIdleOnBargeIn ?? true,
+            sampleRate: options.sampleRate ?? 16000,
+        };
+    }
+    start() {
+        this.unsub = this.client.on((e) => this.handle(e));
+    }
+    stop() {
+        this.unsub?.();
+        this.unsub = null;
+        if (this.pending) {
+            clearTimeout(this.pending.timer);
+            this.pending = null;
+        }
+    }
+    /** Feed one int16 PCM frame: buffered locally for turn slicing AND streamed. */
+    sendAudio(frame) {
+        this.chunks.push(frame);
+        this.totalSamples += frame.length;
+        if (!this.inTurn) {
+            const cap = this.o.idleBufferCapS * this.o.sampleRate;
+            while (this.totalSamples - (this.chunks[0]?.length ?? 0) > cap && this.chunks.length > 1) {
+                this.totalSamples -= this.chunks.shift().length;
+            }
+        }
+        // Pass the view directly — WebSocket.send transmits exactly the view's
+        // bytes (avoids ArrayBuffer/SharedArrayBuffer copies and typing friction).
+        this.client.sendAudio(frame);
+    }
+    /** Resolves once no user turn is open (don't talk over the caller). */
+    async speakGate(pollMs = 100) {
+        while (this.inTurn)
+            await new Promise((r) => setTimeout(r, pollMs));
+    }
+    // ── internals ──────────────────────────────────────────────────────────
+    absStart() {
+        // absolute sample index of the oldest buffered sample
+        return this.totalSamples - this.chunks.reduce((n, c) => n + c.length, 0);
+    }
+    sliceFrom(startSample) {
+        let cursor = this.absStart();
+        const parts = [];
+        for (const c of this.chunks) {
+            const end = cursor + c.length;
+            if (end > startSample) {
+                const off = Math.max(0, startSample - cursor);
+                parts.push(c.subarray(off));
+            }
+            cursor = end;
+        }
+        const total = parts.reduce((n, p) => n + p.length, 0);
+        const out = new Int16Array(total);
+        let i = 0;
+        for (const p of parts) {
+            out.set(p, i);
+            i += p.length;
+        }
+        return out;
+    }
+    trimToLast(seconds) {
+        const keep = seconds * this.o.sampleRate;
+        while (this.totalSamples - (this.absStart() + (this.chunks[0]?.length ?? 0)) >= keep && this.chunks.length > 1) {
+            this.chunks.shift();
+        }
+    }
+    handle(e) {
+        this.o.onEvent(e);
+        switch (e.type) {
+            case "turn_start": {
+                const ts = e;
+                this.inTurn = true;
+                const lb = ts.interrupted_agent ? this.o.bargeInLookbackS : this.o.lookbackS;
+                this.turnSliceStart = Math.max(0, this.totalSamples - lb * this.o.sampleRate);
+                break;
+            }
+            case "turn_end": {
+                if (!this.inTurn)
+                    break;
+                this.inTurn = false;
+                const te = e;
+                const audio = this.sliceFrom(this.turnSliceStart);
+                this.trimToLast(this.o.postTurnKeepS);
+                if (!this.locked) {
+                    this.dispatch(te, audio, true, false, null);
+                }
+                else {
+                    if (this.pending)
+                        clearTimeout(this.pending.timer);
+                    const timer = setTimeout(() => {
+                        if (this.pending && this.pending.timer === timer) {
+                            const p = this.pending;
+                            this.pending = null;
+                            this.dispatch(p.event, p.audio, false, false, null);
+                        }
+                    }, this.o.verifyTimeoutMs);
+                    this.pending = { audioStart: te.audio_start, audio, event: te, timer };
+                }
+                break;
+            }
+            case "speaker_verification": {
+                const v = e;
+                const p = this.pending;
+                if (!p)
+                    break;
+                if (v.audio_start && p.audioStart && Math.abs(v.audio_start - p.audioStart) > VERIFY_MATCH_TOLERANCE_S)
+                    break;
+                clearTimeout(p.timer);
+                this.pending = null;
+                this.dispatchRaw({
+                    speakerId: v.speaker_id,
+                    durationMs: p.event.duration_ms,
+                    endpoint: p.event.endpoint,
+                    interruptedAgent: v.interrupted_agent,
+                }, p.audio, v.should_respond, true, v.similarity);
+                break;
+            }
+            case "barge_in": {
+                if (this.o.autoAgentIdleOnBargeIn)
+                    this.client.agentIdle();
+                this.o.onBargeIn(e);
+                break;
+            }
+            case "lock_status": {
+                this.locked = e.status.startsWith("locked");
+                break;
+            }
+        }
+    }
+    dispatch(te, audio, shouldRespond, verified, similarity) {
+        this.dispatchRaw({
+            speakerId: te.speaker_id,
+            durationMs: te.duration_ms,
+            endpoint: te.endpoint,
+            interruptedAgent: te.interrupted_agent,
+        }, audio, shouldRespond, verified, similarity);
+    }
+    dispatchRaw(meta, audio, shouldRespond, verified, similarity) {
+        const turn = {
+            audio,
+            sampleRate: this.o.sampleRate,
+            speakerId: meta.speakerId,
+            shouldRespond,
+            verified,
+            similarity,
+            interruptedAgent: meta.interruptedAgent,
+            durationMs: meta.durationMs,
+            endpoint: meta.endpoint,
+        };
+        // Queue so async handlers run in order and never drop a turn.
+        this.queue = this.queue.then(() => this.o.onTurn(turn)).catch(() => { });
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "vsip-sdk",
+  "version": "0.1.0",
+  "description": "Official JavaScript/TypeScript SDK for the VSIP Voice Events API — real-time turn detection, identity-gated barge-in, and speaker verification for voice agents.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "voice", "voice-agent", "barge-in", "speaker-verification",
+    "turn-detection", "vad", "websocket", "realtime"
+  ],
+  "license": "MIT",
+  "engines": { "node": ">=18" },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  }
+}