@voxdiscover/voiceserver 0.1.0

package/dist/index.cjs

@@ -0,0 +1,870 @@
+'use strict';
+
+var DailyIframe = require('@daily-co/daily-js');
+var EventEmitter = require('eventemitter3');
+var exponentialBackoff = require('exponential-backoff');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DailyIframe__default = /*#__PURE__*/_interopDefault(DailyIframe);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/VoiceAgent.ts
+
+// src/utils/validation.ts
+function decodeSessionToken(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Malformed session token");
+  }
+  try {
+    const payload = JSON.parse(atob(parts[1]));
+    if (payload.exp && payload.exp * 1e3 < Date.now()) {
+      throw new Error("Session token expired");
+    }
+    return payload;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("expired")) {
+      throw err;
+    }
+    throw new Error("Failed to decode session token");
+  }
+}
+async function validateToken(sessionId, baseUrl = "http://localhost:8000") {
+  const response = await fetch(`${baseUrl}/v1/sessions/${sessionId}`);
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error("Session not found or expired");
+    }
+    throw new Error(`Failed to validate session: ${response.statusText}`);
+  }
+  const session = await response.json();
+  if (session.status !== "active") {
+    throw new Error("Session is no longer active");
+  }
+}
+var ReconnectionManager = class {
+  maxRetries;
+  initialDelayMs;
+  maxDelayMs;
+  constructor(config) {
+    this.maxRetries = config?.maxRetries ?? 5;
+    this.initialDelayMs = config?.initialDelayMs ?? 1e3;
+    this.maxDelayMs = config?.maxDelayMs ?? 3e4;
+  }
+  /**
+   * Execute connection function with exponential backoff retry logic.
+   * Adds jitter to prevent thundering herd problem.
+   */
+  async reconnectWithBackoff(connectFn, onRetry) {
+    return exponentialBackoff.backOff(connectFn, {
+      numOfAttempts: this.maxRetries,
+      startingDelay: this.initialDelayMs,
+      maxDelay: this.maxDelayMs,
+      jitter: "full",
+      // Full jitter to prevent simultaneous retries
+      retry: (err, attempt) => {
+        if (err?.message?.includes("token") || err?.message?.includes("session")) {
+          return false;
+        }
+        const delay = Math.min(
+          this.initialDelayMs * Math.pow(2, attempt - 1),
+          this.maxDelayMs
+        );
+        onRetry?.(attempt, delay);
+        return true;
+      }
+    });
+  }
+};
+
+// src/errors.ts
+var VoiceAgentError = class _VoiceAgentError extends Error {
+  code;
+  cause;
+  context;
+  retryable;
+  constructor(message, code, options) {
+    super(message);
+    this.name = "VoiceAgentError";
+    this.code = code;
+    this.cause = options?.cause;
+    this.context = options?.context;
+    this.retryable = options?.retryable ?? false;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _VoiceAgentError);
+    }
+    Object.setPrototypeOf(this, _VoiceAgentError.prototype);
+  }
+};
+var TokenExpiredError = class _TokenExpiredError extends VoiceAgentError {
+  constructor(message = "Session token has expired", cause) {
+    super(message, "TOKEN_EXPIRED", {
+      cause,
+      retryable: false,
+      context: {
+        suggestion: "Request a new session token from your backend"
+      }
+    });
+    this.name = "TokenExpiredError";
+    Object.setPrototypeOf(this, _TokenExpiredError.prototype);
+  }
+};
+var TokenInvalidError = class _TokenInvalidError extends VoiceAgentError {
+  constructor(message = "Session token is invalid", cause) {
+    super(message, "TOKEN_INVALID", {
+      cause,
+      retryable: false,
+      context: {
+        suggestion: "Verify session token format and request a new token if needed"
+      }
+    });
+    this.name = "TokenInvalidError";
+    Object.setPrototypeOf(this, _TokenInvalidError.prototype);
+  }
+};
+var ConnectionFailedError = class _ConnectionFailedError extends VoiceAgentError {
+  constructor(message, cause) {
+    super(message, "CONNECTION_FAILED", {
+      cause,
+      retryable: true,
+      context: {
+        suggestion: "Check network connection and retry"
+      }
+    });
+    this.name = "ConnectionFailedError";
+    Object.setPrototypeOf(this, _ConnectionFailedError.prototype);
+  }
+};
+var PermissionDeniedError = class _PermissionDeniedError extends VoiceAgentError {
+  constructor(permission) {
+    super(
+      `${permission} permission denied by user`,
+      "PERMISSION_DENIED",
+      {
+        retryable: false,
+        context: {
+          permission,
+          suggestion: `Grant ${permission} permission in browser settings and reload`
+        }
+      }
+    );
+    this.name = "PermissionDeniedError";
+    Object.setPrototypeOf(this, _PermissionDeniedError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends VoiceAgentError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR", {
+      cause,
+      retryable: true,
+      context: {
+        suggestion: "Check internet connection and retry"
+      }
+    });
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+
+// src/VoiceAgent.ts
+var VoiceAgent = class extends EventEmitter__default.default {
+  config;
+  sessionData = null;
+  dailyCall = null;
+  _state = "disconnected";
+  reconnectionManager;
+  /**
+   * Audio elements for remote participants.
+   * Daily.js createCallObject() does not auto-play remote audio — we must
+   * create <audio> elements ourselves in the track-started handler.
+   */
+  remoteAudioElements = /* @__PURE__ */ new Map();
+  /**
+   * Cumulative cost breakdown for the current session.
+   * Per RESEARCH.md Pattern 4: appended on each cost-update app-message.
+   * Reset to [] on disconnect() for clean state on reconnection.
+   */
+  costBreakdown = [];
+  /**
+   * Current agent ID tracked for duplicate-swap guard.
+   * Initialized from session token on connect().
+   */
+  currentAgentId = null;
+  /**
+   * Registered analytics callbacks.
+   * Per RESEARCH.md Pattern 5: observer pattern for lifecycle and error events.
+   */
+  analyticsCallbacks = [];
+  /**
+   * Circuit breaker counter for analytics to prevent infinite loops.
+   * Per RESEARCH.md Pitfall #5: if same event emitted >10 times/second, disable analytics.
+   */
+  analyticsCallCount = 0;
+  analyticsCallResetTimer = null;
+  analyticsDisabled = false;
+  /**
+   * Optional mem0 memory client for client-side conversation memory.
+   * Initialized from config.mem0ApiKey via dynamic import (optional peer dependency).
+   * Per RESEARCH.md Pattern 3: client-side pattern syncs on session end.
+   */
+  memoryClient = null;
+  /**
+   * Transcript history for mem0 sync on session end.
+   * Accumulates final transcripts as {role, content} pairs.
+   * Reset on disconnect() for clean state on reconnection.
+   */
+  transcriptHistory = [];
+  /**
+   * Create VoiceAgent instance.
+   * Per user decision: constructor pattern, minimal config (only token required).
+   */
+  constructor(config) {
+    super();
+    this.config = {
+      baseUrl: config.baseUrl ?? "http://localhost:8000",
+      reconnection: {
+        enabled: config.reconnection?.enabled ?? true,
+        maxAttempts: config.reconnection?.maxAttempts ?? 5
+      },
+      ...config
+    };
+    this.reconnectionManager = new ReconnectionManager({
+      maxRetries: this.config.reconnection?.maxAttempts
+    });
+    if (this.config.mem0ApiKey) {
+      this.initMemoryClient().catch((err) => {
+        console.warn("[VoiceAgent] mem0 initialization failed:", err);
+      });
+    }
+  }
+  /**
+   * Get current connection state.
+   * Per user decision: read-only state property.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Register an analytics callback for lifecycle and error events.
+   *
+   * Emits: session_started, session_ended, connection_failed, and error events.
+   *
+   * IMPORTANT: Analytics callbacks MUST be read-only. Do NOT call SDK methods
+   * (connect, disconnect, mute, etc.) inside a callback. Doing so will trigger
+   * the circuit breaker and disable analytics for the remainder of the session.
+   * See RESEARCH.md Pitfall #5.
+   *
+   * @param callback Function called with each analytics event
+   *
+   * @example
+   * ```typescript
+   * agent.onAnalyticsEvent((event) => {
+   *   // Integrate with Segment, DataDog, PostHog, etc.
+   *   analytics.track(event.eventType, {
+   *     session_id: event.sessionId,
+   *     user_id: event.userId,
+   *   });
+   * });
+   * ```
+   */
+  onAnalyticsEvent(callback) {
+    this.analyticsCallbacks.push(callback);
+  }
+  /**
+   * Search user memories from mem0 for context-aware responses.
+   *
+   * Requires mem0ApiKey and userId in config. Returns empty array if mem0
+   * is not configured or an error occurs.
+   *
+   * @param query Search query (e.g., "user preferences", "previous orders")
+   * @param limit Maximum number of results (default: 5)
+   * @returns Array of memory objects with 'memory' and 'score' fields
+   *
+   * @example
+   * ```typescript
+   * const memories = await agent.searchMemories('user preferences', 3);
+   * memories.forEach(m => console.log(m.memory));
+   * ```
+   */
+  async searchMemories(query, limit = 5) {
+    if (!this.memoryClient || !this.config.userId) {
+      return [];
+    }
+    try {
+      const result = await this.memoryClient.search(query, {
+        user_id: this.config.userId,
+        limit
+      });
+      return Array.isArray(result) ? result : result?.results ?? [];
+    } catch (err) {
+      console.error("[VoiceAgent] mem0 search failed:", err);
+      return [];
+    }
+  }
+  /**
+   * Initialize optional mem0 memory client via dynamic import.
+   * Uses dynamic import so missing mem0ai package is a soft warning, not an error.
+   * Per RESEARCH.md Pattern 3 (Client-side - Web SDK).
+   */
+  async initMemoryClient() {
+    try {
+      const { MemoryClient } = await import('mem0ai');
+      this.memoryClient = new MemoryClient({ apiKey: this.config.mem0ApiKey });
+    } catch {
+      console.warn(
+        "[VoiceAgent] mem0ai package not found. Install with: npm install mem0ai\nSee: https://docs.mem0.ai/platform/quickstart"
+      );
+    }
+  }
+  /**
+   * Emit analytics event to all registered callbacks.
+   * Per RESEARCH.md Pattern 5: try/catch per callback prevents analytics errors from breaking SDK.
+   * Per RESEARCH.md Pitfall #5: circuit breaker disables analytics on excessive calls.
+   */
+  emitAnalyticsEvent(event) {
+    if (this.analyticsDisabled || this.analyticsCallbacks.length === 0) {
+      return;
+    }
+    this.analyticsCallCount++;
+    if (this.analyticsCallResetTimer === null) {
+      this.analyticsCallResetTimer = setTimeout(() => {
+        this.analyticsCallCount = 0;
+        this.analyticsCallResetTimer = null;
+      }, 1e3);
+    }
+    if (this.analyticsCallCount > 10) {
+      this.analyticsDisabled = true;
+      console.error(
+        "[VoiceAgent] Analytics disabled: >10 events emitted in 1 second. Ensure analytics callbacks are read-only and do not call SDK methods."
+      );
+      return;
+    }
+    for (const callback of this.analyticsCallbacks) {
+      try {
+        callback(event);
+      } catch (err) {
+        console.error("[VoiceAgent] Analytics callback error:", err);
+      }
+    }
+  }
+  /**
+   * Connect to voice session.
+   * Per user decision: explicit connect(), async validation before connect.
+   */
+  async connect() {
+    if (this._state !== "disconnected") {
+      throw new Error("Already connected or connecting");
+    }
+    this.setState("connecting");
+    try {
+      this.sessionData = decodeSessionToken(this.config.token);
+      await validateToken(this.sessionData.session_id, this.config.baseUrl);
+      this.dailyCall = DailyIframe__default.default.createCallObject({
+        audioSource: true,
+        videoSource: false,
+        dailyConfig: {
+          avoidEval: true
+          // CSP-friendly
+        }
+      });
+      this.setupDailyEventListeners();
+      await this.dailyCall.join({ url: this.sessionData.room_url, token: this.sessionData.daily_token });
+    } catch (err) {
+      this.setState("failed");
+      if (err instanceof Error) {
+        let typedError;
+        if (err.message.includes("expired")) {
+          typedError = new TokenExpiredError(err.message, err);
+        } else if (err.message.includes("Malformed") || err.message.includes("decode")) {
+          typedError = new TokenInvalidError(err.message, err);
+        } else if (err.message.includes("Session not found")) {
+          typedError = new TokenExpiredError("Session not found or expired", err);
+        } else if (err.message.includes("validate")) {
+          typedError = new NetworkError(`Failed to validate session: ${err.message}`, err);
+        } else {
+          typedError = new ConnectionFailedError(err.message, err);
+        }
+        this.emit("connection:error", typedError);
+        throw typedError;
+      }
+      const error = new ConnectionFailedError(String(err));
+      this.emit("connection:error", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from voice session.
+   * Per user decision: full cleanup (leave + destroy + remove listeners).
+   * Per RESEARCH.md Pitfall 2: Both leave() and destroy() required.
+   */
+  async disconnect() {
+    if (!this.dailyCall) {
+      return;
+    }
+    const sessionDataSnapshot = this.sessionData;
+    try {
+      await this.dailyCall.leave();
+      await this.dailyCall.destroy();
+    } catch (err) {
+      console.error("Disconnect error:", err);
+    } finally {
+      if (this.memoryClient && this.config.userId && this.transcriptHistory.length > 0) {
+        try {
+          await this.memoryClient.add(this.transcriptHistory, { user_id: this.config.userId });
+        } catch (err) {
+          console.error("[VoiceAgent] mem0 memory sync failed (non-fatal):", err);
+        }
+      }
+      for (const audio of this.remoteAudioElements.values()) {
+        audio.pause();
+        audio.srcObject = null;
+      }
+      this.remoteAudioElements.clear();
+      this.dailyCall = null;
+      this.sessionData = null;
+      this.costBreakdown = [];
+      this.transcriptHistory = [];
+      this.setState("disconnected");
+      this.emitAnalyticsEvent({
+        timestamp: Date.now(),
+        eventType: "session_ended",
+        sessionId: sessionDataSnapshot?.session_id ?? "unknown",
+        agentId: sessionDataSnapshot?.agent_id,
+        userId: sessionDataSnapshot?.user_id
+      });
+    }
+  }
+  /**
+   * Mute microphone.
+   */
+  mute() {
+    if (!this.dailyCall) {
+      throw new Error("Not connected");
+    }
+    this.dailyCall.setLocalAudio(false);
+    this.emit("audio:muted");
+  }
+  /**
+   * Unmute microphone.
+   */
+  unmute() {
+    if (!this.dailyCall) {
+      throw new Error("Not connected");
+    }
+    this.dailyCall.setLocalAudio(true);
+    this.emit("audio:unmuted");
+  }
+  /**
+   * Update session context mid-session.
+   *
+   * Per Phase 15 ADV-02: allows developer to update user_id, customer_id,
+   * session_metadata, and custom JSON during an active session.
+   *
+   * Validates context client-side (10KB size, 50 fields) with warnings.
+   * POSTs to /v1/sessions/{session_id}/context endpoint.
+   * Emits 'context:updated' event on success.
+   *
+   * @param contextUpdates Partial context to merge into existing session context
+   * @throws Error if no active session
+   * @throws Error if the context update API call fails
+   *
+   * @example
+   * ```typescript
+   * await agent.updateContext({
+   *   user_id: 'user_123',
+   *   custom: { preferred_language: 'Spanish', loyalty_tier: 'gold' }
+   * });
+   * ```
+   */
+  async updateContext(contextUpdates) {
+    if (!this.sessionData) {
+      throw new Error("Cannot update context: no active session");
+    }
+    this.validateContext(contextUpdates);
+    const response = await fetch(
+      `${this.config.baseUrl}/v1/sessions/${this.sessionData.session_id}/context`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.token}`
+        },
+        body: JSON.stringify({ context: contextUpdates })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Context update failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const updateData = {
+      updates: contextUpdates,
+      timestamp: Date.now()
+    };
+    this.emit("context:updated", updateData);
+  }
+  /**
+   * Validate context client-side for size (10KB) and field count (50 max).
+   * Validation is permissive: warns but does not throw on limits exceeded.
+   * Per user decision: don't break session on validation warning.
+   *
+   * @param context Context object to validate
+   */
+  validateContext(context) {
+    const serialized = JSON.stringify(context);
+    const sizeBytes = new Blob([serialized]).size;
+    if (sizeBytes > 10240) {
+      console.warn(
+        `[VoiceAgent] Context size (${sizeBytes} bytes) exceeds 10KB limit. Backend will truncate custom fields.`
+      );
+    }
+    const customFieldCount = Object.keys(context.custom ?? {}).length;
+    if (customFieldCount > 50) {
+      console.warn(
+        `[VoiceAgent] Custom context has ${customFieldCount} fields (limit: 50). Backend will truncate to first 50 fields.`
+      );
+    }
+  }
+  /**
+   * Switch agent mid-session without disconnecting WebRTC.
+   *
+   * Per Phase 15 ADV-01: hot-swap the backend bot while keeping the Daily room
+   * connection alive. The new agent receives full conversation context and
+   * transcript history.
+   *
+   * Protocol:
+   * 1. Validate connected and not already using newAgentId
+   * 2. Emit agent:swapping event (for analytics / UI loading indicator)
+   * 3. Send Daily app-message to backend bot requesting swap
+   * 4. Wait for agent-swap-complete confirmation (with timeout)
+   * 5. Update currentAgentId and emit agent:swapped on success
+   * 6. Emit agent:swap-failed and throw on timeout or backend error
+   *
+   * @param newAgentId UUID of the agent to swap to
+   * @param options Swap options (preserveContext, preserveTranscripts, timeout)
+   * @throws Error if not connected, already using newAgentId, or swap fails/times out
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await agent.switchAgent('specialist-agent-uuid');
+   *   console.log('Agent switched successfully');
+   * } catch (err) {
+   *   console.error('Swap failed:', err);
+   *   // Old agent is still active (resilient fallback)
+   * }
+   * ```
+   */
+  async switchAgent(newAgentId, options = {}) {
+    const {
+      preserveContext = true,
+      preserveTranscripts = true,
+      timeout = 5e3
+    } = options;
+    if (!this.dailyCall || this._state !== "connected") {
+      throw new Error("Cannot switch agent: not connected");
+    }
+    if (this.currentAgentId === newAgentId) {
+      throw new Error("Already using this agent");
+    }
+    const timestamp = Date.now();
+    const sessionId = this.sessionData?.session_id ?? "unknown";
+    this.emit("agent:swapping", { newAgentId, timestamp });
+    this.emitAnalyticsEvent({
+      timestamp,
+      eventType: "agent_swap_completed",
+      // will be overridden on failure
+      sessionId,
+      agentId: newAgentId
+    });
+    try {
+      this.dailyCall.sendAppMessage({
+        type: "agent-swap-request",
+        new_agent_id: newAgentId,
+        preserve_context: preserveContext,
+        preserve_transcripts: preserveTranscripts
+      }, "*");
+      await this.waitForSwapConfirmation(newAgentId, timeout);
+      this.currentAgentId = newAgentId;
+      this.emit("agent:swapped", { newAgentId, timestamp: Date.now() });
+      this.emitAnalyticsEvent({
+        timestamp: Date.now(),
+        eventType: "agent_swap_completed",
+        sessionId,
+        agentId: newAgentId
+      });
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.emit("agent:swap-failed", { newAgentId, timestamp: Date.now(), error: errorMessage });
+      this.emitAnalyticsEvent({
+        timestamp: Date.now(),
+        eventType: "agent_swap_failed",
+        sessionId,
+        agentId: newAgentId,
+        error: {
+          code: "AGENT_SWAP_ERROR",
+          message: errorMessage,
+          retryable: true
+        }
+      });
+      throw new Error(`Agent swap failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Wait for backend agent-swap-complete confirmation via Daily app-message.
+   *
+   * Resolves when agent-swap-complete is received with matching agent_id.
+   * Rejects on agent-swap-failed message or timeout.
+   *
+   * @param agentId Expected new agent ID in confirmation
+   * @param timeoutMs Milliseconds before timing out
+   */
+  waitForSwapConfirmation(agentId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Agent swap timeout \u2014 new agent failed to connect"));
+      }, timeoutMs);
+      const handler = (event) => {
+        const data = event?.data;
+        if (!data) return;
+        if (data.type === "agent-swap-complete" && data.agent_id === agentId) {
+          cleanup();
+          resolve();
+        } else if (data.type === "agent-swap-failed") {
+          cleanup();
+          reject(new Error(data.error || "Backend agent swap failed"));
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.dailyCall?.off("app-message", handler);
+      };
+      this.dailyCall?.on("app-message", handler);
+    });
+  }
+  /**
+   * Subscribe to real-time cost updates for the session.
+   *
+   * Registers a callback that is called after each provider API call (STT, LLM, TTS)
+   * with the cumulative cost summary including a breakdown by provider and service type.
+   *
+   * Per RESEARCH.md Pattern 4: Backend streams cost events; SDK aggregates and exposes
+   * via this callback for developer integration (budget alerts, user-facing displays).
+   *
+   * @param callback Function called with CostSummary on each cost update
+   *
+   * @example
+   * ```typescript
+   * agent.onCostUpdate((summary) => {
+   *   console.log(`Session cost: $${summary.totalUsd.toFixed(4)}`);
+   *   console.log('By provider:', summary.byProvider);
+   *   console.log('By service:', summary.byServiceType);
+   * });
+   * ```
+   */
+  onCostUpdate(callback) {
+    this.on("cost:update", callback);
+  }
+  /**
+   * Get the current cumulative cost summary for the session.
+   *
+   * Returns a snapshot of all costs incurred so far, aggregated by provider
+   * and service type. Returns empty summary if no costs have been tracked.
+   *
+   * @returns CostSummary with totalUsd, breakdown array, byProvider, and byServiceType
+   */
+  getCostSummary() {
+    const totalUsd = this.costBreakdown.reduce((sum, b) => sum + b.costUsd, 0);
+    const byProvider = {};
+    const byServiceType = {};
+    for (const b of this.costBreakdown) {
+      byProvider[b.provider] = (byProvider[b.provider] ?? 0) + b.costUsd;
+      byServiceType[b.serviceType] = (byServiceType[b.serviceType] ?? 0) + b.costUsd;
+    }
+    return {
+      totalUsd,
+      breakdown: [...this.costBreakdown],
+      byProvider,
+      byServiceType
+    };
+  }
+  /**
+   * Set up cost tracking subscription on the Daily call object.
+   * Per RESEARCH.md Pattern 4: subscribe to cost-update app-messages from backend.
+   * Called from setupDailyEventListeners() after Daily call object is created.
+   */
+  setupCostTracking() {
+    if (!this.dailyCall) return;
+    this.dailyCall.on("app-message", this.handleCostUpdate);
+  }
+  /**
+   * Handle cost-update app-message from backend bot.
+   * Parses cost event, appends to costBreakdown, and emits cost:update event.
+   * Per RESEARCH.md Pattern 4: cost events contain provider, service_type, model, cost_usd.
+   */
+  handleCostUpdate = (event) => {
+    const data = event?.data;
+    if (!data || data.type !== "cost-update") {
+      return;
+    }
+    const { provider, service_type, model, cost_usd, timestamp } = data;
+    if (!provider || !service_type || !model || typeof cost_usd !== "number") {
+      return;
+    }
+    const breakdown = {
+      provider,
+      serviceType: service_type,
+      model,
+      costUsd: cost_usd,
+      timestamp: timestamp ?? Date.now()
+    };
+    this.costBreakdown.push(breakdown);
+    this.emit("cost:update", this.getCostSummary());
+  };
+  setState(newState) {
+    this._state = newState;
+    this.emit("connection:state", newState);
+  }
+  setupDailyEventListeners() {
+    if (!this.dailyCall) return;
+    this.dailyCall.on("joined-meeting", this.handleJoined).on("left-meeting", this.handleLeft).on("participant-joined", this.handleParticipantJoined).on("participant-left", this.handleParticipantLeft).on("track-started", this.handleTrackStarted).on("track-stopped", this.handleTrackStopped).on("error", this.handleDailyError).on("app-message", this.handleTranscript);
+    this.setupCostTracking();
+  }
+  handleJoined = () => {
+    this.setState("connected");
+    this.currentAgentId = this.sessionData?.agent_id ?? null;
+    this.emitAnalyticsEvent({
+      timestamp: Date.now(),
+      eventType: "session_started",
+      sessionId: this.sessionData?.session_id ?? "unknown",
+      agentId: this.sessionData?.agent_id,
+      userId: this.sessionData?.user_id
+    });
+  };
+  handleLeft = () => {
+    this.setState("disconnected");
+  };
+  handleParticipantJoined = () => {
+  };
+  handleParticipantLeft = (event) => {
+    const participantId = event?.participant?.session_id;
+    if (!participantId) return;
+    const audio = this.remoteAudioElements.get(participantId);
+    if (audio) {
+      audio.pause();
+      audio.srcObject = null;
+      this.remoteAudioElements.delete(participantId);
+    }
+  };
+  /**
+   * Create and play an <audio> element when a remote participant's audio track starts.
+   * Daily.js createCallObject() does NOT auto-play remote audio in headless mode —
+   * the app must handle track-started and wire the track to an audio element.
+   */
+  handleTrackStarted = (event) => {
+    const { participant, track, type } = event;
+    if (participant?.local || type !== "audio" || !track) return;
+    const participantId = participant.session_id;
+    let audio = this.remoteAudioElements.get(participantId);
+    if (!audio) {
+      audio = new Audio();
+      this.remoteAudioElements.set(participantId, audio);
+    }
+    audio.srcObject = new MediaStream([track]);
+    audio.play().catch((err) => {
+      console.warn("[VoiceAgent] Remote audio playback failed:", err);
+    });
+  };
+  handleTrackStopped = (event) => {
+    const { participant, type } = event;
+    if (participant?.local || type !== "audio") return;
+    const participantId = participant.session_id;
+    const audio = this.remoteAudioElements.get(participantId);
+    if (audio) {
+      audio.pause();
+      audio.srcObject = null;
+      this.remoteAudioElements.delete(participantId);
+    }
+  };
+  handleDailyError = (error) => {
+    const errorMsg = error?.errorMsg || "Unknown Daily.js error";
+    let typedError;
+    if (errorMsg.includes("token") || errorMsg.includes("expired")) {
+      typedError = new TokenExpiredError("Daily token invalid or expired");
+    } else if (errorMsg.includes("permission") || errorMsg.includes("microphone")) {
+      typedError = new PermissionDeniedError("microphone");
+    } else if (errorMsg.includes("network") || errorMsg.includes("connection")) {
+      typedError = new ConnectionFailedError(errorMsg);
+    } else {
+      typedError = new ConnectionFailedError(errorMsg);
+    }
+    this.emit("connection:error", typedError);
+    this.emitAnalyticsEvent({
+      timestamp: Date.now(),
+      eventType: "connection_failed",
+      sessionId: this.sessionData?.session_id ?? "unknown",
+      agentId: this.sessionData?.agent_id,
+      userId: this.sessionData?.user_id,
+      error: {
+        code: typedError.code,
+        message: typedError.message,
+        retryable: typedError.retryable
+      }
+    });
+    if (typedError.retryable && this.config.reconnection?.enabled && this._state === "connected") {
+      this.attemptReconnect();
+    }
+  };
+  handleTranscript = (event) => {
+    const { text, speaker, is_final } = event.data || {};
+    if (!text || !speaker) return;
+    const transcriptData = {
+      text,
+      speaker: speaker === "local" ? "user" : "agent",
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    if (is_final) {
+      this.transcriptHistory.push({
+        role: speaker === "local" ? "user" : "assistant",
+        content: text
+      });
+      this.emit("transcript:final", transcriptData);
+    } else {
+      this.emit("transcript:interim", transcriptData);
+    }
+  };
+  async attemptReconnect() {
+    if (this._state === "reconnecting") return;
+    this.setState("reconnecting");
+    try {
+      await this.reconnectionManager.reconnectWithBackoff(
+        async () => {
+          if (!this.dailyCall || !this.sessionData) {
+            throw new Error("Cannot reconnect: no active session");
+          }
+          await this.dailyCall.join({ url: this.sessionData.room_url, token: this.sessionData.daily_token });
+        },
+        (attempt, delay) => {
+          console.log(`Reconnection attempt ${attempt}, waiting ${delay}ms`);
+        }
+      );
+    } catch (err) {
+      this.setState("failed");
+      const error = err instanceof VoiceAgentError ? err : new ConnectionFailedError("Failed to reconnect after multiple attempts", err);
+      this.emit("connection:error", error);
+    }
+  }
+};
+
+exports.ConnectionFailedError = ConnectionFailedError;
+exports.NetworkError = NetworkError;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.ReconnectionManager = ReconnectionManager;
+exports.TokenExpiredError = TokenExpiredError;
+exports.TokenInvalidError = TokenInvalidError;
+exports.VoiceAgent = VoiceAgent;
+exports.VoiceAgentError = VoiceAgentError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map