@vattara/sdk 1.0.0 → 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,96 @@
+/**
+ * @vattara/sdk — Official TypeScript SDK for Vattara Observe
+ * Realtime PCM audio streaming, interruption tracking, token cost analytics & CLEAR 2.0 metrics.
+ */
+interface VattaraOptions {
+    apiKey: string;
+    serverUrl?: string;
+    sampleRate?: 16000 | 24000;
+    tags?: Record<string, string>;
+    debug?: boolean;
+    maxBufferSize?: number;
+    maxRetries?: number;
+    onError?: (error: Error) => void;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+}
+interface InterruptionEvent {
+    cutoffLatencyMs: number;
+    interruptedAt?: number;
+}
+interface TokenUsageEvent {
+    inputTokens: number;
+    outputTokens: number;
+    model?: string;
+}
+interface TranscriptEvent {
+    text: string;
+    role?: 'caller' | 'agent' | 'user' | 'bot' | 'assistant';
+    timestamp?: number;
+}
+interface LatencyEvent {
+    kind: string;
+    valueMs: number;
+}
+type VattaraEventType = 'audio_frame' | 'interruption' | 'token_usage' | 'transcript' | 'latency' | 'session_start' | 'session_end' | 'call_ended';
+interface VattaraEvent {
+    type: VattaraEventType;
+    [key: string]: unknown;
+}
+declare class VattaraObserveClient {
+    private apiKey;
+    private serverUrl;
+    private sampleRate;
+    private tags;
+    private debug;
+    private maxBufferSize;
+    private maxRetries;
+    private onError?;
+    private onConnect?;
+    private onDisconnect?;
+    private ws;
+    private token;
+    private buffer;
+    private isConnecting;
+    private retryCount;
+    private retryTimer;
+    private destroyed;
+    constructor(options: VattaraOptions);
+    /** Initialize session by fetching JWT token and establishing WebSocket connection. */
+    init(): Promise<void>;
+    /** Track PCM audio base64 frame (16kHz / 24kHz). */
+    sendAudioFrame(base64Data: string, sampleRate?: number): void;
+    /** Track customer barge-in / interruption event. */
+    trackInterruption(event: InterruptionEvent): void;
+    /** Track input/output token usage. */
+    trackTokens(event: TokenUsageEvent): void;
+    /** Track a transcript turn (caller or agent speech). */
+    trackTranscript(event: TranscriptEvent): void;
+    /** Track a latency measurement. */
+    trackLatency(event: LatencyEvent): void;
+    /** Signal the start of a new call session. */
+    sessionStart(): void;
+    /** Signal the end of the current call session. */
+    sessionEnd(): void;
+    /** Set dynamic custom properties/tags. */
+    setTags(tags: Record<string, string>): void;
+    /** Cleanly close the connection and release resources. */
+    disconnect(): void;
+    private sendEvent;
+    private flushBuffer;
+    private scheduleReconnect;
+}
+declare const Vattara: {
+    init(options: VattaraOptions): VattaraObserveClient;
+    sendAudioFrame(base64Data: string, sampleRate?: number): void;
+    trackInterruption(event: InterruptionEvent): void;
+    trackTokens(event: TokenUsageEvent): void;
+    trackTranscript(event: TranscriptEvent): void;
+    trackLatency(event: LatencyEvent): void;
+    sessionStart(): void;
+    sessionEnd(): void;
+    setTags(tags: Record<string, string>): void;
+    disconnect(): void;
+};
+
+export { type InterruptionEvent, type LatencyEvent, type TokenUsageEvent, type TranscriptEvent, Vattara, type VattaraEvent, type VattaraEventType, VattaraObserveClient, type VattaraOptions };

package/dist/index.d.ts

@@ -2,32 +2,59 @@
  * @vattara/sdk — Official TypeScript SDK for Vattara Observe
  * Realtime PCM audio streaming, interruption tracking, token cost analytics & CLEAR 2.0 metrics.
  */
-export interface VattaraOptions {
+interface VattaraOptions {
     apiKey: string;
     serverUrl?: string;
     sampleRate?: 16000 | 24000;
     tags?: Record<string, string>;
     debug?: boolean;
+    maxBufferSize?: number;
+    maxRetries?: number;
+    onError?: (error: Error) => void;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
 }
-export interface InterruptionEvent {
+interface InterruptionEvent {
     cutoffLatencyMs: number;
     interruptedAt?: number;
 }
-export interface TokenUsageEvent {
+interface TokenUsageEvent {
     inputTokens: number;
     outputTokens: number;
     model?: string;
 }
-export declare class VattaraObserveClient {
+interface TranscriptEvent {
+    text: string;
+    role?: 'caller' | 'agent' | 'user' | 'bot' | 'assistant';
+    timestamp?: number;
+}
+interface LatencyEvent {
+    kind: string;
+    valueMs: number;
+}
+type VattaraEventType = 'audio_frame' | 'interruption' | 'token_usage' | 'transcript' | 'latency' | 'session_start' | 'session_end' | 'call_ended';
+interface VattaraEvent {
+    type: VattaraEventType;
+    [key: string]: unknown;
+}
+declare class VattaraObserveClient {
     private apiKey;
     private serverUrl;
     private sampleRate;
     private tags;
     private debug;
+    private maxBufferSize;
+    private maxRetries;
+    private onError?;
+    private onConnect?;
+    private onDisconnect?;
     private ws;
     private token;
     private buffer;
     private isConnecting;
+    private retryCount;
+    private retryTimer;
+    private destroyed;
     constructor(options: VattaraOptions);
     /** Initialize session by fetching JWT token and establishing WebSocket connection. */
     init(): Promise<void>;
@@ -37,15 +64,33 @@ export declare class VattaraObserveClient {
     trackInterruption(event: InterruptionEvent): void;
     /** Track input/output token usage. */
     trackTokens(event: TokenUsageEvent): void;
+    /** Track a transcript turn (caller or agent speech). */
+    trackTranscript(event: TranscriptEvent): void;
+    /** Track a latency measurement. */
+    trackLatency(event: LatencyEvent): void;
+    /** Signal the start of a new call session. */
+    sessionStart(): void;
+    /** Signal the end of the current call session. */
+    sessionEnd(): void;
     /** Set dynamic custom properties/tags. */
     setTags(tags: Record<string, string>): void;
+    /** Cleanly close the connection and release resources. */
+    disconnect(): void;
     private sendEvent;
     private flushBuffer;
+    private scheduleReconnect;
 }
-export declare const Vattara: {
+declare const Vattara: {
     init(options: VattaraOptions): VattaraObserveClient;
     sendAudioFrame(base64Data: string, sampleRate?: number): void;
     trackInterruption(event: InterruptionEvent): void;
     trackTokens(event: TokenUsageEvent): void;
+    trackTranscript(event: TranscriptEvent): void;
+    trackLatency(event: LatencyEvent): void;
+    sessionStart(): void;
+    sessionEnd(): void;
     setTags(tags: Record<string, string>): void;
+    disconnect(): void;
 };
+
+export { type InterruptionEvent, type LatencyEvent, type TokenUsageEvent, type TranscriptEvent, Vattara, type VattaraEvent, type VattaraEventType, VattaraObserveClient, type VattaraOptions };

package/dist/index.js

@@ -30,15 +30,25 @@ var VattaraObserveClient = class {
     this.token = null;
     this.buffer = [];
     this.isConnecting = false;
+    this.retryCount = 0;
+    this.retryTimer = null;
+    this.destroyed = false;
     this.apiKey = options.apiKey;
     this.serverUrl = options.serverUrl || "wss://vattara-observe-production.up.railway.app/api/v1/ws/telemetry";
     this.sampleRate = options.sampleRate || 24e3;
     this.tags = options.tags || {};
     this.debug = options.debug || false;
+    this.maxBufferSize = options.maxBufferSize ?? 1e3;
+    this.maxRetries = options.maxRetries ?? 10;
+    this.onError = options.onError;
+    this.onConnect = options.onConnect;
+    this.onDisconnect = options.onDisconnect;
   }
   /** Initialize session by fetching JWT token and establishing WebSocket connection. */
   async init() {
-    if (this.isConnecting || this.ws) return;
+    if (this.destroyed) return;
+    if (this.isConnecting || this.ws && this.ws.readyState === WebSocket.OPEN)
+      return;
     this.isConnecting = true;
     try {
       const httpUrl = this.serverUrl.replace(/^ws/, "http").replace(/\/ws\/telemetry$/, "/auth/token");
@@ -52,21 +62,33 @@ var VattaraObserveClient = class {
       }
       const data = await res.json();
       this.token = data.token;
+      this.retryCount = 0;
       const wsUrl = `${this.serverUrl}?token=${encodeURIComponent(this.token)}`;
       this.ws = new WebSocket(wsUrl);
       this.ws.onopen = () => {
         if (this.debug) console.log("[Vattara] Telemetry WebSocket connected.");
         this.flushBuffer();
+        this.onConnect?.();
       };
       this.ws.onclose = () => {
-        if (this.debug) console.log("[Vattara] Telemetry WebSocket disconnected.");
+        if (this.debug)
+          console.log("[Vattara] Telemetry WebSocket disconnected.");
         this.ws = null;
+        this.onDisconnect?.();
+        if (!this.destroyed) {
+          this.scheduleReconnect();
+        }
       };
       this.ws.onerror = (err) => {
         if (this.debug) console.error("[Vattara] WebSocket error:", err);
       };
     } catch (err) {
-      if (this.debug) console.error("[Vattara] Initialization error:", err);
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (this.debug) console.error("[Vattara] Initialization error:", error);
+      this.onError?.(error);
+      if (!this.destroyed) {
+        this.scheduleReconnect();
+      }
     } finally {
       this.isConnecting = false;
     }
@@ -85,7 +107,8 @@ var VattaraObserveClient = class {
     this.sendEvent({
       type: "interruption",
       cutoffLatencyMs: event.cutoffLatencyMs,
-      interruptedAt: event.interruptedAt || Date.now()
+      interruptedAt: event.interruptedAt || Date.now(),
+      timestamp: Date.now()
     });
   }
   /** Track input/output token usage. */
@@ -98,15 +121,70 @@ var VattaraObserveClient = class {
       timestamp: Date.now()
     });
   }
+  /** Track a transcript turn (caller or agent speech). */
+  trackTranscript(event) {
+    this.sendEvent({
+      type: "transcript",
+      text: event.text,
+      role: event.role || "caller",
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /** Track a latency measurement. */
+  trackLatency(event) {
+    this.sendEvent({
+      type: "latency",
+      kind: event.kind,
+      valueMs: event.valueMs,
+      timestamp: Date.now()
+    });
+  }
+  /** Signal the start of a new call session. */
+  sessionStart() {
+    this.sendEvent({
+      type: "session_start",
+      timestamp: Date.now()
+    });
+  }
+  /** Signal the end of the current call session. */
+  sessionEnd() {
+    this.sendEvent({
+      type: "session_end",
+      timestamp: Date.now()
+    });
+  }
   /** Set dynamic custom properties/tags. */
   setTags(tags) {
     this.tags = { ...this.tags, ...tags };
   }
+  /** Cleanly close the connection and release resources. */
+  disconnect() {
+    this.destroyed = true;
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.buffer = [];
+  }
   sendEvent(payload) {
+    if (this.destroyed) return;
     const fullPayload = { ...payload, tags: this.tags };
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(fullPayload));
     } else {
+      if (this.buffer.length >= this.maxBufferSize) {
+        this.buffer.shift();
+        if (this.debug)
+          console.warn(
+            "[Vattara] Buffer full \u2014 dropped oldest event."
+          );
+      }
       this.buffer.push(fullPayload);
       if (!this.isConnecting && !this.ws) {
         this.init();
@@ -119,10 +197,32 @@ var VattaraObserveClient = class {
       this.ws.send(JSON.stringify(payload));
     }
   }
+  scheduleReconnect() {
+    if (this.destroyed) return;
+    if (this.retryCount >= this.maxRetries) {
+      const error = new Error(
+        `[Vattara] Max reconnect attempts (${this.maxRetries}) exhausted.`
+      );
+      if (this.debug) console.error(error.message);
+      this.onError?.(error);
+      return;
+    }
+    const delay = Math.min(1e3 * 2 ** this.retryCount, 3e4);
+    this.retryCount++;
+    if (this.debug)
+      console.log(
+        `[Vattara] Reconnecting in ${delay}ms (attempt ${this.retryCount}/${this.maxRetries})...`
+      );
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.init();
+    }, delay);
+  }
 };
 var _globalClient = null;
 var Vattara = {
   init(options) {
+    _globalClient?.disconnect();
     _globalClient = new VattaraObserveClient(options);
     _globalClient.init();
     return _globalClient;
@@ -136,8 +236,24 @@ var Vattara = {
   trackTokens(event) {
     _globalClient?.trackTokens(event);
   },
+  trackTranscript(event) {
+    _globalClient?.trackTranscript(event);
+  },
+  trackLatency(event) {
+    _globalClient?.trackLatency(event);
+  },
+  sessionStart() {
+    _globalClient?.sessionStart();
+  },
+  sessionEnd() {
+    _globalClient?.sessionEnd();
+  },
   setTags(tags) {
     _globalClient?.setTags(tags);
+  },
+  disconnect() {
+    _globalClient?.disconnect();
+    _globalClient = null;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.mjs

@@ -5,15 +5,25 @@ var VattaraObserveClient = class {
     this.token = null;
     this.buffer = [];
     this.isConnecting = false;
+    this.retryCount = 0;
+    this.retryTimer = null;
+    this.destroyed = false;
     this.apiKey = options.apiKey;
     this.serverUrl = options.serverUrl || "wss://vattara-observe-production.up.railway.app/api/v1/ws/telemetry";
     this.sampleRate = options.sampleRate || 24e3;
     this.tags = options.tags || {};
     this.debug = options.debug || false;
+    this.maxBufferSize = options.maxBufferSize ?? 1e3;
+    this.maxRetries = options.maxRetries ?? 10;
+    this.onError = options.onError;
+    this.onConnect = options.onConnect;
+    this.onDisconnect = options.onDisconnect;
   }
   /** Initialize session by fetching JWT token and establishing WebSocket connection. */
   async init() {
-    if (this.isConnecting || this.ws) return;
+    if (this.destroyed) return;
+    if (this.isConnecting || this.ws && this.ws.readyState === WebSocket.OPEN)
+      return;
     this.isConnecting = true;
     try {
       const httpUrl = this.serverUrl.replace(/^ws/, "http").replace(/\/ws\/telemetry$/, "/auth/token");
@@ -27,21 +37,33 @@ var VattaraObserveClient = class {
       }
       const data = await res.json();
       this.token = data.token;
+      this.retryCount = 0;
       const wsUrl = `${this.serverUrl}?token=${encodeURIComponent(this.token)}`;
       this.ws = new WebSocket(wsUrl);
       this.ws.onopen = () => {
         if (this.debug) console.log("[Vattara] Telemetry WebSocket connected.");
         this.flushBuffer();
+        this.onConnect?.();
       };
       this.ws.onclose = () => {
-        if (this.debug) console.log("[Vattara] Telemetry WebSocket disconnected.");
+        if (this.debug)
+          console.log("[Vattara] Telemetry WebSocket disconnected.");
         this.ws = null;
+        this.onDisconnect?.();
+        if (!this.destroyed) {
+          this.scheduleReconnect();
+        }
       };
       this.ws.onerror = (err) => {
         if (this.debug) console.error("[Vattara] WebSocket error:", err);
       };
     } catch (err) {
-      if (this.debug) console.error("[Vattara] Initialization error:", err);
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (this.debug) console.error("[Vattara] Initialization error:", error);
+      this.onError?.(error);
+      if (!this.destroyed) {
+        this.scheduleReconnect();
+      }
     } finally {
       this.isConnecting = false;
     }
@@ -60,7 +82,8 @@ var VattaraObserveClient = class {
     this.sendEvent({
       type: "interruption",
       cutoffLatencyMs: event.cutoffLatencyMs,
-      interruptedAt: event.interruptedAt || Date.now()
+      interruptedAt: event.interruptedAt || Date.now(),
+      timestamp: Date.now()
     });
   }
   /** Track input/output token usage. */
@@ -73,15 +96,70 @@ var VattaraObserveClient = class {
       timestamp: Date.now()
     });
   }
+  /** Track a transcript turn (caller or agent speech). */
+  trackTranscript(event) {
+    this.sendEvent({
+      type: "transcript",
+      text: event.text,
+      role: event.role || "caller",
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /** Track a latency measurement. */
+  trackLatency(event) {
+    this.sendEvent({
+      type: "latency",
+      kind: event.kind,
+      valueMs: event.valueMs,
+      timestamp: Date.now()
+    });
+  }
+  /** Signal the start of a new call session. */
+  sessionStart() {
+    this.sendEvent({
+      type: "session_start",
+      timestamp: Date.now()
+    });
+  }
+  /** Signal the end of the current call session. */
+  sessionEnd() {
+    this.sendEvent({
+      type: "session_end",
+      timestamp: Date.now()
+    });
+  }
   /** Set dynamic custom properties/tags. */
   setTags(tags) {
     this.tags = { ...this.tags, ...tags };
   }
+  /** Cleanly close the connection and release resources. */
+  disconnect() {
+    this.destroyed = true;
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.buffer = [];
+  }
   sendEvent(payload) {
+    if (this.destroyed) return;
     const fullPayload = { ...payload, tags: this.tags };
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(fullPayload));
     } else {
+      if (this.buffer.length >= this.maxBufferSize) {
+        this.buffer.shift();
+        if (this.debug)
+          console.warn(
+            "[Vattara] Buffer full \u2014 dropped oldest event."
+          );
+      }
       this.buffer.push(fullPayload);
       if (!this.isConnecting && !this.ws) {
         this.init();
@@ -94,10 +172,32 @@ var VattaraObserveClient = class {
       this.ws.send(JSON.stringify(payload));
     }
   }
+  scheduleReconnect() {
+    if (this.destroyed) return;
+    if (this.retryCount >= this.maxRetries) {
+      const error = new Error(
+        `[Vattara] Max reconnect attempts (${this.maxRetries}) exhausted.`
+      );
+      if (this.debug) console.error(error.message);
+      this.onError?.(error);
+      return;
+    }
+    const delay = Math.min(1e3 * 2 ** this.retryCount, 3e4);
+    this.retryCount++;
+    if (this.debug)
+      console.log(
+        `[Vattara] Reconnecting in ${delay}ms (attempt ${this.retryCount}/${this.maxRetries})...`
+      );
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.init();
+    }, delay);
+  }
 };
 var _globalClient = null;
 var Vattara = {
   init(options) {
+    _globalClient?.disconnect();
     _globalClient = new VattaraObserveClient(options);
     _globalClient.init();
     return _globalClient;
@@ -111,8 +211,24 @@ var Vattara = {
   trackTokens(event) {
     _globalClient?.trackTokens(event);
   },
+  trackTranscript(event) {
+    _globalClient?.trackTranscript(event);
+  },
+  trackLatency(event) {
+    _globalClient?.trackLatency(event);
+  },
+  sessionStart() {
+    _globalClient?.sessionStart();
+  },
+  sessionEnd() {
+    _globalClient?.sessionEnd();
+  },
   setTags(tags) {
     _globalClient?.setTags(tags);
+  },
+  disconnect() {
+    _globalClient?.disconnect();
+    _globalClient = null;
   }
 };
 export {

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@vattara/sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Official TypeScript SDK for Vattara Observe — Realtime AI Voice Agent Observability & CLEAR 2.0 Evaluation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm && tsc --emitDeclarationOnly"
+    "build": "tsup src/index.ts --format cjs,esm --dts"
   },
   "keywords": [
     "vattara",

package/src/index.ts

@@ -1,170 +0,0 @@
-/**
- * @vattara/sdk — Official TypeScript SDK for Vattara Observe
- * Realtime PCM audio streaming, interruption tracking, token cost analytics & CLEAR 2.0 metrics.
- */
-
-export interface VattaraOptions {
-  apiKey: string;
-  serverUrl?: string;
-  sampleRate?: 16000 | 24000;
-  tags?: Record<string, string>;
-  debug?: boolean;
-}
-
-export interface InterruptionEvent {
-  cutoffLatencyMs: number;
-  interruptedAt?: number;
-}
-
-export interface TokenUsageEvent {
-  inputTokens: number;
-  outputTokens: number;
-  model?: string;
-}
-
-export class VattaraObserveClient {
-  private apiKey: string;
-  private serverUrl: string;
-  private sampleRate: number;
-  private tags: Record<string, string>;
-  private debug: boolean;
-  private ws: WebSocket | null = null;
-  private token: string | null = null;
-  private buffer: any[] = [];
-  private isConnecting: boolean = false;
-
-  constructor(options: VattaraOptions) {
-    this.apiKey = options.apiKey;
-    this.serverUrl = options.serverUrl || 'wss://vattara-observe-production.up.railway.app/api/v1/ws/telemetry';
-    this.sampleRate = options.sampleRate || 24000;
-    this.tags = options.tags || {};
-    this.debug = options.debug || false;
-  }
-
-  /** Initialize session by fetching JWT token and establishing WebSocket connection. */
-  async init(): Promise<void> {
-    if (this.isConnecting || this.ws) return;
-    this.isConnecting = true;
-
-    try {
-      // Exchange API Key for short-lived JWT token
-      const httpUrl = this.serverUrl.replace(/^ws/, 'http').replace(/\/ws\/telemetry$/, '/auth/token');
-      const res = await fetch(httpUrl, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ api_key: this.apiKey }),
-      });
-
-      if (!res.ok) {
-        throw new Error(`Authentication failed with status ${res.status}`);
-      }
-
-      const data = await res.json();
-      this.token = data.token;
-
-      // Establish WebSocket Connection
-      const wsUrl = `${this.serverUrl}?token=${encodeURIComponent(this.token!)}`;
-      this.ws = new WebSocket(wsUrl);
-
-      this.ws.onopen = () => {
-        if (this.debug) console.log('[Vattara] Telemetry WebSocket connected.');
-        this.flushBuffer();
-      };
-
-      this.ws.onclose = () => {
-        if (this.debug) console.log('[Vattara] Telemetry WebSocket disconnected.');
-        this.ws = null;
-      };
-
-      this.ws.onerror = (err) => {
-        if (this.debug) console.error('[Vattara] WebSocket error:', err);
-      };
-
-    } catch (err) {
-      if (this.debug) console.error('[Vattara] Initialization error:', err);
-    } finally {
-      this.isConnecting = false;
-    }
-  }
-
-  /** Track PCM audio base64 frame (16kHz / 24kHz). */
-  sendAudioFrame(base64Data: string, sampleRate?: number): void {
-    this.sendEvent({
-      type: 'audio_frame',
-      sampleRate: sampleRate || this.sampleRate,
-      data: base64Data,
-      timestamp: Date.now(),
-    });
-  }
-
-  /** Track customer barge-in / interruption event. */
-  trackInterruption(event: InterruptionEvent): void {
-    this.sendEvent({
-      type: 'interruption',
-      cutoffLatencyMs: event.cutoffLatencyMs,
-      interruptedAt: event.interruptedAt || Date.now(),
-    });
-  }
-
-  /** Track input/output token usage. */
-  trackTokens(event: TokenUsageEvent): void {
-    this.sendEvent({
-      type: 'token_usage',
-      inputTokens: event.inputTokens,
-      outputTokens: event.outputTokens,
-      model: event.model || 'gpt-4o-realtime',
-      timestamp: Date.now(),
-    });
-  }
-
-  /** Set dynamic custom properties/tags. */
-  setTags(tags: Record<string, string>): void {
-    this.tags = { ...this.tags, ...tags };
-  }
-
-  private sendEvent(payload: any): void {
-    const fullPayload = { ...payload, tags: this.tags };
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(fullPayload));
-    } else {
-      this.buffer.push(fullPayload);
-      if (!this.isConnecting && !this.ws) {
-        this.init();
-      }
-    }
-  }
-
-  private flushBuffer(): void {
-    while (this.buffer.length > 0 && this.ws && this.ws.readyState === WebSocket.OPEN) {
-      const payload = this.buffer.shift();
-      this.ws.send(JSON.stringify(payload));
-    }
-  }
-}
-
-/** Global Singleton Helper (CAST AI Style) */
-let _globalClient: VattaraObserveClient | null = null;
-
-export const Vattara = {
-  init(options: VattaraOptions): VattaraObserveClient {
-    _globalClient = new VattaraObserveClient(options);
-    _globalClient.init();
-    return _globalClient;
-  },
-
-  sendAudioFrame(base64Data: string, sampleRate?: number): void {
-    _globalClient?.sendAudioFrame(base64Data, sampleRate);
-  },
-
-  trackInterruption(event: InterruptionEvent): void {
-    _globalClient?.trackInterruption(event);
-  },
-
-  trackTokens(event: TokenUsageEvent): void {
-    _globalClient?.trackTokens(event);
-  },
-
-  setTags(tags: Record<string, string>): void {
-    _globalClient?.setTags(tags);
-  },
-};

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*"]
-}