@omote/core 0.5.3 → 0.5.4

package/dist/index.js

@@ -33,17 +33,14 @@ __export(index_exports, {
   A2EOrchestrator: () => A2EOrchestrator,
   A2EProcessor: () => A2EProcessor,
   ARKIT_BLENDSHAPES: () => ARKIT_BLENDSHAPES,
-  AgentCoreAdapter: () => AgentCoreAdapter,
   AnimationGraph: () => AnimationGraph,
   AudioChunkCoalescer: () => AudioChunkCoalescer,
   AudioEnergyAnalyzer: () => AudioEnergyAnalyzer,
   AudioScheduler: () => AudioScheduler,
-  AudioSyncManager: () => AudioSyncManager,
   BLENDSHAPE_TO_GROUP: () => BLENDSHAPE_TO_GROUP,
   BlendshapeSmoother: () => BlendshapeSmoother,
   CTC_VOCAB: () => CTC_VOCAB,
   ConsoleExporter: () => ConsoleExporter,
-  ConversationOrchestrator: () => ConversationOrchestrator,
   DEFAULT_ANIMATION_CONFIG: () => DEFAULT_ANIMATION_CONFIG,
   DEFAULT_LOGGING_CONFIG: () => DEFAULT_LOGGING_CONFIG,
   EMOTION_NAMES: () => EMOTION_NAMES,
@@ -73,7 +70,6 @@ __export(index_exports, {
   SileroVADInference: () => SileroVADInference,
   SileroVADUnifiedAdapter: () => SileroVADUnifiedAdapter,
   SileroVADWorker: () => SileroVADWorker,
-  TenantManager: () => TenantManager,
   UnifiedInferenceWorker: () => UnifiedInferenceWorker,
   Wav2ArkitCpuInference: () => Wav2ArkitCpuInference,
   Wav2ArkitCpuUnifiedAdapter: () => Wav2ArkitCpuUnifiedAdapter,
@@ -3188,13 +3184,6 @@ function pcm16ToFloat32(buffer) {
   }
   return float32;
 }
-function int16ToFloat32(int16) {
-  const float32 = new Float32Array(int16.length);
-  for (let i = 0; i < int16.length; i++) {
-    float32[i] = int16[i] / 32768;
-  }
-  return float32;
-}
 
 // src/audio/FullFacePipeline.ts
 var logger4 = createLogger("FullFacePipeline");
@@ -3482,6 +3471,108 @@ var FullFacePipeline = class extends EventEmitter {
   }
 };
 
+// src/audio/InterruptionHandler.ts
+var InterruptionHandler = class extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.isSpeaking = false;
+    this.speechStartTime = 0;
+    this.lastSpeechTime = 0;
+    this.silenceTimer = null;
+    this.aiIsSpeaking = false;
+    // Debouncing: only emit one interruption per speech session
+    this.interruptionTriggeredThisSession = false;
+    this.config = {
+      vadThreshold: 0.5,
+      // Silero VAD default
+      minSpeechDurationMs: 200,
+      // Google/Amazon barge-in standard
+      silenceTimeoutMs: 500,
+      // OpenAI Realtime API standard
+      enabled: true,
+      ...config
+    };
+  }
+  /**
+   * Process VAD result for interruption detection
+   * @param vadProbability - Speech probability from VAD (0-1)
+   * @param audioEnergy - Optional RMS energy for logging (default: 0)
+   */
+  processVADResult(vadProbability, audioEnergy = 0) {
+    if (!this.config.enabled) return;
+    if (vadProbability > this.config.vadThreshold) {
+      this.onSpeechDetected(audioEnergy || vadProbability);
+    } else {
+      this.onSilenceDetected();
+    }
+  }
+  /** Notify that AI started/stopped speaking */
+  setAISpeaking(speaking) {
+    this.aiIsSpeaking = speaking;
+  }
+  /** Enable/disable interruption detection */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+    if (!enabled) {
+      this.reset();
+    }
+  }
+  /** Update configuration */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /** Reset state */
+  reset() {
+    this.isSpeaking = false;
+    this.speechStartTime = 0;
+    this.lastSpeechTime = 0;
+    this.interruptionTriggeredThisSession = false;
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = null;
+    }
+  }
+  /** Get current state */
+  getState() {
+    return {
+      isSpeaking: this.isSpeaking,
+      speechDurationMs: this.isSpeaking ? Date.now() - this.speechStartTime : 0
+    };
+  }
+  onSpeechDetected(rms) {
+    const now = Date.now();
+    this.lastSpeechTime = now;
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = null;
+    }
+    if (!this.isSpeaking) {
+      this.isSpeaking = true;
+      this.speechStartTime = now;
+      this.emit("speech.detected", { rms });
+    }
+    if (this.aiIsSpeaking && !this.interruptionTriggeredThisSession) {
+      const speechDuration = now - this.speechStartTime;
+      if (speechDuration >= this.config.minSpeechDurationMs) {
+        this.interruptionTriggeredThisSession = true;
+        this.emit("interruption.triggered", { rms, durationMs: speechDuration });
+      }
+    }
+  }
+  onSilenceDetected() {
+    if (!this.isSpeaking) return;
+    if (!this.silenceTimer) {
+      this.silenceTimer = setTimeout(() => {
+        const durationMs = this.lastSpeechTime - this.speechStartTime;
+        this.isSpeaking = false;
+        this.silenceTimer = null;
+        this.interruptionTriggeredThisSession = false;
+        this.emit("speech.ended", { durationMs });
+      }, this.config.silenceTimeoutMs);
+    }
+  }
+};
+
 // src/inference/kaldiFbank.ts
 function fft(re, im) {
   const n = re.length;
@@ -9188,1214 +9279,6 @@ var EmotionController = class {
   }
 };
 
-// src/ai/adapters/AgentCoreAdapter.ts
-var AgentCoreAdapter = class extends EventEmitter {
-  constructor(config) {
-    super();
-    this.name = "AgentCore";
-    this._state = "disconnected";
-    this._sessionId = null;
-    this._isConnected = false;
-    // Sub-components
-    this.asr = null;
-    this.vad = null;
-    this.lam = null;
-    this.pipeline = null;
-    // WebSocket connection to AgentCore
-    this.ws = null;
-    this.wsReconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    // Audio buffers
-    this.audioBuffer = [];
-    // Conversation state
-    this.history = [];
-    this.currentConfig = null;
-    // Interruption handling
-    this.isSpeaking = false;
-    this.currentTtsAbortController = null;
-    // Auth token cache per tenant
-    this.tokenCache = /* @__PURE__ */ new Map();
-    this.agentCoreConfig = config;
-    this.emotionController = new EmotionController();
-  }
-  get state() {
-    return this._state;
-  }
-  get sessionId() {
-    return this._sessionId;
-  }
-  get isConnected() {
-    return this._isConnected;
-  }
-  /**
-   * Connect to AgentCore with session configuration
-   */
-  async connect(config) {
-    this.currentConfig = config;
-    this._sessionId = config.sessionId;
-    try {
-      const authToken = await this.getAuthToken(config.tenant);
-      await Promise.all([
-        this.initASR(),
-        this.initLAM()
-      ]);
-      await this.connectWebSocket(authToken, config);
-      this._isConnected = true;
-      this.setState("idle");
-      this.emit("connection.opened", { sessionId: this._sessionId, adapter: this.name });
-    } catch (error) {
-      this.setState("error");
-      this.emit("connection.error", {
-        error,
-        recoverable: true
-      });
-      throw error;
-    }
-  }
-  /**
-   * Disconnect and cleanup
-   */
-  async disconnect() {
-    this.currentTtsAbortController?.abort();
-    if (this.pipeline) {
-      this.pipeline.dispose();
-      this.pipeline = null;
-    }
-    if (this.ws) {
-      this.ws.close(1e3, "Client disconnect");
-      this.ws = null;
-    }
-    await Promise.all([
-      this.asr?.dispose(),
-      this.vad?.dispose(),
-      this.lam?.dispose()
-    ]);
-    this._isConnected = false;
-    this.setState("disconnected");
-    this.emit("connection.closed", { reason: "Client disconnect" });
-  }
-  /**
-   * Push user audio for processing
-   */
-  pushAudio(audio) {
-    if (!this._isConnected) return;
-    if (this.isSpeaking) {
-      this.detectVoiceActivity(audio).then((hasVoiceActivity) => {
-        if (hasVoiceActivity) {
-          this.interrupt();
-        }
-      }).catch((error) => {
-        console.error("[AgentCore] VAD error during interruption detection:", error);
-      });
-    }
-    const float32 = audio instanceof Float32Array ? audio : int16ToFloat32(audio);
-    this.audioBuffer.push(float32);
-    this.scheduleTranscription();
-  }
-  /**
-   * Send text directly to AgentCore
-   */
-  async sendText(text) {
-    if (!this._isConnected || !this.ws) {
-      throw new Error("Not connected to AgentCore");
-    }
-    this.addToHistory({
-      role: "user",
-      content: text,
-      timestamp: Date.now()
-    });
-    this.setState("thinking");
-    this.emit("ai.thinking.start", { timestamp: Date.now() });
-    this.ws.send(JSON.stringify({
-      type: "user_message",
-      sessionId: this._sessionId,
-      content: text,
-      context: {
-        history: this.history.slice(-10),
-        // Last 10 messages
-        emotion: Array.from(this.emotionController.emotion)
-      }
-    }));
-  }
-  /**
-   * Interrupt current AI response
-   */
-  interrupt() {
-    if (!this.isSpeaking) return;
-    this.emit("interruption.detected", { timestamp: Date.now() });
-    this.currentTtsAbortController?.abort();
-    this.currentTtsAbortController = null;
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({
-        type: "interrupt",
-        sessionId: this._sessionId,
-        timestamp: Date.now()
-      }));
-    }
-    this.isSpeaking = false;
-    this.setState("listening");
-    this.emit("interruption.handled", { timestamp: Date.now(), action: "stop" });
-  }
-  getHistory() {
-    return [...this.history];
-  }
-  clearHistory() {
-    this.history = [];
-    this.emit("memory.updated", { messageCount: 0 });
-  }
-  async healthCheck() {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      return false;
-    }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 5e3);
-      const handler = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          if (data.type === "pong") {
-            clearTimeout(timeout);
-            this.ws?.removeEventListener("message", handler);
-            resolve(true);
-          }
-        } catch {
-        }
-      };
-      this.ws?.addEventListener("message", handler);
-      this.ws?.send(JSON.stringify({ type: "ping" }));
-    });
-  }
-  // ==================== Private Methods ====================
-  setState(state) {
-    const previousState = this._state;
-    this._state = state;
-    this.emit("state.change", { state, previousState });
-  }
-  async getAuthToken(tenant) {
-    const cached = this.tokenCache.get(tenant.tenantId);
-    if (cached && cached.expiresAt > Date.now() + 6e4) {
-      return cached.token;
-    }
-    if (tenant.credentials.authToken) {
-      return tenant.credentials.authToken;
-    }
-    const endpoint = this.agentCoreConfig.endpoint;
-    if (endpoint.startsWith("ws://") || endpoint.includes("localhost")) {
-      return "local-dev-token";
-    }
-    const httpEndpoint = endpoint.replace("wss://", "https://").replace("ws://", "http://");
-    const response = await fetch(`${httpEndpoint}/auth/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        tenantId: tenant.tenantId,
-        apiKey: tenant.credentials.apiKey
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Auth failed: ${response.statusText}`);
-    }
-    const { token, expiresIn } = await response.json();
-    this.tokenCache.set(tenant.tenantId, {
-      token,
-      expiresAt: Date.now() + expiresIn * 1e3
-    });
-    return token;
-  }
-  async initASR() {
-    await Promise.all([
-      // SenseVoice ASR
-      (async () => {
-        this.asr = new SenseVoiceInference({
-          modelUrl: "/models/sensevoice/model.int8.onnx",
-          language: "auto"
-        });
-        await this.asr.load();
-      })(),
-      // Silero VAD for accurate voice activity detection
-      (async () => {
-        this.vad = new SileroVADInference({
-          modelUrl: "/models/silero-vad.onnx",
-          backend: "webgpu",
-          sampleRate: 16e3,
-          threshold: 0.5
-        });
-        await this.vad.load();
-      })()
-    ]);
-  }
-  async initLAM() {
-    const lamUrl = this.agentCoreConfig.models?.lamUrl || "/models/unified_wav2vec2_asr_a2e.onnx";
-    this.lam = new Wav2Vec2Inference({
-      modelUrl: lamUrl,
-      backend: "auto"
-    });
-    await this.lam.load();
-    await this.initPipeline();
-  }
-  async initPipeline() {
-    if (!this.lam) {
-      throw new Error("LAM must be initialized before pipeline");
-    }
-    this.pipeline = new FullFacePipeline({
-      lam: this.lam,
-      sampleRate: 16e3,
-      chunkTargetMs: 200
-    });
-    await this.pipeline.initialize();
-    this.pipeline.on("full_frame_ready", (fullFrame) => {
-      const frame = fullFrame.blendshapes;
-      this.emit("animation", {
-        blendshapes: frame,
-        get: (name) => {
-          const idx = LAM_BLENDSHAPES.indexOf(name);
-          return idx >= 0 ? frame[idx] : 0;
-        },
-        timestamp: Date.now(),
-        // Wall clock for client-side logging only
-        inferenceMs: 0
-        // Pipeline handles LAM inference asynchronously
-      });
-    });
-    this.pipeline.on("playback_complete", () => {
-      this.isSpeaking = false;
-      this.setState("idle");
-      this.emit("audio.output.end", { durationMs: 0 });
-    });
-    this.pipeline.on("error", (error) => {
-      console.error("[AgentCore] Pipeline error:", error);
-      this.emit("connection.error", {
-        error,
-        recoverable: true
-      });
-    });
-  }
-  async connectWebSocket(authToken, config) {
-    return new Promise((resolve, reject) => {
-      const wsUrl = new URL(`${this.agentCoreConfig.endpoint.replace("http", "ws")}/ws`);
-      wsUrl.searchParams.set("sessionId", config.sessionId);
-      wsUrl.searchParams.set("characterId", config.tenant.characterId);
-      this.ws = new WebSocket(wsUrl.toString());
-      this.ws.onopen = () => {
-        this.ws?.send(JSON.stringify({
-          type: "auth",
-          token: authToken,
-          tenantId: config.tenant.tenantId,
-          systemPrompt: config.systemPrompt
-        }));
-      };
-      this.ws.onmessage = (event) => {
-        try {
-          this.handleAgentCoreMessage(JSON.parse(event.data));
-        } catch {
-        }
-      };
-      this.ws.onerror = () => {
-        reject(new Error("WebSocket connection failed"));
-      };
-      this.ws.onclose = (event) => {
-        this.handleDisconnect(event);
-      };
-      const authTimeout = setTimeout(() => {
-        reject(new Error("Auth timeout"));
-      }, 1e4);
-      const authHandler = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          if (data.type === "auth_success") {
-            clearTimeout(authTimeout);
-            this.ws?.removeEventListener("message", authHandler);
-            resolve();
-          } else if (data.type === "auth_failed") {
-            clearTimeout(authTimeout);
-            reject(new Error(data.message));
-          }
-        } catch {
-        }
-      };
-      this.ws.addEventListener("message", authHandler);
-    });
-  }
-  handleAgentCoreMessage(data) {
-    switch (data.type) {
-      case "response_start":
-        this.setState("speaking");
-        this.isSpeaking = true;
-        this.emit("ai.response.start", {
-          text: data.text,
-          emotion: data.emotion
-        });
-        if (data.emotion) {
-          this.emotionController.transitionTo(
-            { [data.emotion]: 0.7 },
-            300
-          );
-        }
-        if (this.pipeline) {
-          this.pipeline.start();
-        }
-        break;
-      case "response_chunk":
-        this.emit("ai.response.chunk", {
-          text: data.text,
-          isLast: data.isLast
-        });
-        break;
-      case "audio_chunk":
-        if (data.audio && this.pipeline) {
-          const audioData = this.base64ToArrayBuffer(data.audio);
-          const uint8 = new Uint8Array(audioData);
-          this.pipeline.onAudioChunk(uint8).catch((error) => {
-            console.error("[AgentCore] Pipeline chunk error:", error);
-          });
-        }
-        break;
-      case "audio_end":
-        if (this.pipeline) {
-          this.pipeline.end().catch((error) => {
-            console.error("[AgentCore] Pipeline end error:", error);
-          });
-        }
-        break;
-      case "response_end":
-        this.addToHistory({
-          role: "assistant",
-          content: data.fullText,
-          timestamp: Date.now(),
-          emotion: data.emotion
-        });
-        this.emit("ai.response.end", {
-          fullText: data.fullText,
-          durationMs: data.durationMs || 0
-        });
-        break;
-      case "memory_updated":
-        this.emit("memory.updated", {
-          messageCount: data.messageCount,
-          tokenCount: data.tokenCount
-        });
-        break;
-      case "error":
-        this.emit("connection.error", {
-          error: new Error(data.message),
-          recoverable: data.recoverable ?? false
-        });
-        break;
-    }
-  }
-  scheduleTranscription() {
-    if (this.audioBuffer.length === 0) return;
-    const totalLength = this.audioBuffer.reduce((sum2, buf) => sum2 + buf.length, 0);
-    if (totalLength < 4e3) return;
-    const audio = new Float32Array(totalLength);
-    let offset = 0;
-    for (const buf of this.audioBuffer) {
-      audio.set(buf, offset);
-      offset += buf.length;
-    }
-    this.audioBuffer = [];
-    let sum = 0;
-    for (let i = 0; i < audio.length; i++) {
-      sum += audio[i] * audio[i];
-    }
-    const rms = Math.sqrt(sum / audio.length);
-    if (rms < 0.01) {
-      console.debug("[AgentCore] Skipping silent audio", { rms, samples: audio.length });
-      return;
-    }
-    if (this.asr) {
-      this.setState("listening");
-      this.emit("user.speech.start", { timestamp: Date.now() });
-      this.asr.transcribe(audio).then((result) => {
-        this.emit("user.transcript.final", {
-          text: result.text,
-          confidence: 1
-        });
-        this.emit("user.speech.end", { timestamp: Date.now(), durationMs: result.inferenceTimeMs });
-        const cleanText = result.text.trim();
-        if (cleanText) {
-          this.sendText(cleanText).catch((error) => {
-            console.error("[AgentCore] Send text error:", error);
-          });
-        }
-      }).catch((error) => {
-        console.error("[AgentCore] Transcription error:", error);
-      });
-    }
-  }
-  // REMOVED: processAudioForAnimation() - now handled by FullFacePipeline
-  // The pipeline manages audio scheduling, LAM inference, and frame synchronization
-  // Frames are emitted via pipeline.on('full_frame_ready') event (see initPipeline())
-  /**
-   * Detect voice activity using Silero VAD
-   * Falls back to simple RMS if VAD not available
-   */
-  async detectVoiceActivity(audio) {
-    const float32 = audio instanceof Float32Array ? audio : int16ToFloat32(audio);
-    if (this.vad) {
-      const chunkSize = this.vad.getChunkSize();
-      for (let i = 0; i + chunkSize <= float32.length; i += chunkSize) {
-        const chunk = float32.slice(i, i + chunkSize);
-        const result = await this.vad.process(chunk);
-        if (result.isSpeech) {
-          return true;
-        }
-      }
-      return false;
-    }
-    let sum = 0;
-    for (let i = 0; i < float32.length; i++) {
-      sum += float32[i] * float32[i];
-    }
-    const rms = Math.sqrt(sum / float32.length);
-    return rms > 0.02;
-  }
-  base64ToArrayBuffer(base64) {
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer;
-  }
-  addToHistory(message) {
-    this.history.push(message);
-    this.emit("memory.updated", { messageCount: this.history.length });
-  }
-  handleDisconnect(event) {
-    this._isConnected = false;
-    if (event.code !== 1e3) {
-      if (this.wsReconnectAttempts < this.maxReconnectAttempts) {
-        this.wsReconnectAttempts++;
-        setTimeout(() => {
-          if (this.currentConfig) {
-            this.connect(this.currentConfig).catch(() => {
-            });
-          }
-        }, Math.pow(2, this.wsReconnectAttempts) * 1e3);
-      } else {
-        this.setState("error");
-        this.emit("connection.error", {
-          error: new Error("Max reconnection attempts reached"),
-          recoverable: false
-        });
-      }
-    }
-    this.emit("connection.closed", { reason: event.reason || "Connection closed" });
-  }
-};
-
-// src/ai/orchestration/ConversationOrchestrator.ts
-var ConversationSessionImpl = class {
-  constructor(config, adapter) {
-    this._history = [];
-    this._context = /* @__PURE__ */ new Map();
-    this.sessionId = config.sessionId;
-    this._config = config;
-    this._adapter = adapter;
-    this.createdAt = Date.now();
-    this._lastActivityAt = Date.now();
-    this._emotionController = new EmotionController();
-    if (config.emotion) {
-      this._emotionController.setPreset(config.emotion);
-    }
-  }
-  get adapter() {
-    return this._adapter;
-  }
-  get config() {
-    return this._config;
-  }
-  get state() {
-    return this._adapter.state;
-  }
-  get history() {
-    return [...this._history];
-  }
-  get emotion() {
-    return {};
-  }
-  get lastActivityAt() {
-    return this._lastActivityAt;
-  }
-  async start() {
-    await this._adapter.connect(this._config);
-    this._lastActivityAt = Date.now();
-  }
-  async end() {
-    await this._adapter.disconnect();
-  }
-  pushAudio(audio) {
-    this._adapter.pushAudio(audio);
-    this._lastActivityAt = Date.now();
-  }
-  async sendText(text) {
-    await this._adapter.sendText(text);
-    this._lastActivityAt = Date.now();
-  }
-  interrupt() {
-    this._adapter.interrupt();
-    this._lastActivityAt = Date.now();
-  }
-  setEmotion(emotion) {
-    this._emotionController.set(emotion);
-  }
-  addContext(key, value) {
-    this._context.set(key, value);
-  }
-  removeContext(key) {
-    this._context.delete(key);
-  }
-  getContext() {
-    return Object.fromEntries(this._context);
-  }
-  export() {
-    return {
-      sessionId: this.sessionId,
-      tenantId: this._config.tenant.tenantId,
-      characterId: this._config.tenant.characterId,
-      history: this._history,
-      context: Object.fromEntries(this._context),
-      emotion: this.emotion,
-      createdAt: this.createdAt,
-      lastActivityAt: this._lastActivityAt
-    };
-  }
-  import(snapshot) {
-    this._history = [...snapshot.history];
-    this._context = new Map(Object.entries(snapshot.context));
-    this._lastActivityAt = snapshot.lastActivityAt;
-  }
-  syncHistory() {
-    this._history = this._adapter.getHistory();
-  }
-};
-var ConversationOrchestrator = class extends EventEmitter {
-  constructor(config) {
-    super();
-    // Sessions per tenant
-    this.sessions = /* @__PURE__ */ new Map();
-    // Tenant configurations
-    this.tenants = /* @__PURE__ */ new Map();
-    // Health monitoring
-    this.healthCheckInterval = null;
-    this.HEALTH_CHECK_INTERVAL_MS = 3e4;
-    this.config = {
-      connectionTimeoutMs: 5e3,
-      maxRetries: 3,
-      ...config
-    };
-    this.adapter = new AgentCoreAdapter(config.adapter);
-  }
-  /**
-   * Register a tenant
-   */
-  registerTenant(tenant) {
-    this.tenants.set(tenant.tenantId, tenant);
-  }
-  /**
-   * Unregister a tenant
-   */
-  unregisterTenant(tenantId) {
-    this.tenants.delete(tenantId);
-  }
-  /**
-   * Get tenant config
-   */
-  getTenant(tenantId) {
-    return this.tenants.get(tenantId);
-  }
-  /**
-   * Create a new conversation session for a tenant
-   */
-  async createSession(tenantId, options = {}) {
-    const tenant = this.tenants.get(tenantId);
-    if (!tenant) {
-      throw new Error(`Tenant not found: ${tenantId}`);
-    }
-    const sessionId = options.sessionId || this.generateSessionId();
-    const sessionConfig = {
-      sessionId,
-      tenant,
-      systemPrompt: options.systemPrompt,
-      voice: options.voice,
-      emotion: options.emotion,
-      language: options.language
-    };
-    const session = new ConversationSessionImpl(sessionConfig, this.adapter);
-    this.sessions.set(sessionId, session);
-    this.forwardAdapterEvents(this.adapter, sessionId);
-    await session.start();
-    this.emit("session.created", { sessionId, tenantId });
-    return session;
-  }
-  /**
-   * End a session
-   */
-  async endSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      await session.end();
-      this.sessions.delete(sessionId);
-      this.emit("session.ended", { sessionId, reason: "Client requested" });
-    }
-  }
-  /**
-   * Get session by ID
-   */
-  getSession(sessionId) {
-    return this.sessions.get(sessionId);
-  }
-  /**
-   * Get all sessions for a tenant
-   */
-  getTenantSessions(tenantId) {
-    return Array.from(this.sessions.values()).filter((s) => s.config.tenant.tenantId === tenantId);
-  }
-  /**
-   * Start health monitoring
-   */
-  startHealthMonitoring() {
-    if (this.healthCheckInterval) return;
-    this.healthCheckInterval = setInterval(async () => {
-      await this.performHealthCheck();
-    }, this.HEALTH_CHECK_INTERVAL_MS);
-  }
-  /**
-   * Stop health monitoring
-   */
-  stopHealthMonitoring() {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-      this.healthCheckInterval = null;
-    }
-  }
-  /**
-   * Dispose all resources
-   */
-  async dispose() {
-    this.stopHealthMonitoring();
-    const endPromises = Array.from(this.sessions.values()).map((s) => s.end());
-    await Promise.all(endPromises);
-    this.sessions.clear();
-    await this.adapter.disconnect();
-  }
-  // ==================== Private Methods ====================
-  generateSessionId() {
-    return `sess_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-  forwardAdapterEvents(adapter, sessionId) {
-    const events = [
-      "state.change",
-      "user.speech.start",
-      "user.speech.end",
-      "user.transcript.partial",
-      "user.transcript.final",
-      "ai.thinking.start",
-      "ai.response.start",
-      "ai.response.chunk",
-      "ai.response.end",
-      "audio.output.chunk",
-      "audio.output.end",
-      "animation",
-      "memory.updated",
-      "connection.error",
-      "interruption.detected",
-      "interruption.handled"
-    ];
-    for (const event of events) {
-      adapter.on(event, (data) => {
-        const eventData = data;
-        this.emit(event, { ...eventData, sessionId });
-      });
-    }
-  }
-  async performHealthCheck() {
-    try {
-      await this.adapter.healthCheck();
-    } catch {
-    }
-  }
-};
-
-// src/ai/tenancy/TenantManager.ts
-var _TenantManager = class _TenantManager {
-  constructor() {
-    this.tenants = /* @__PURE__ */ new Map();
-    this.quotas = /* @__PURE__ */ new Map();
-    this.usage = /* @__PURE__ */ new Map();
-    this.tokenRefreshCallbacks = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a tenant with quota
-   */
-  register(tenant, quota = _TenantManager.DEFAULT_QUOTA, tokenRefreshCallback) {
-    this.tenants.set(tenant.tenantId, tenant);
-    this.quotas.set(tenant.tenantId, quota);
-    this.usage.set(tenant.tenantId, {
-      currentSessions: 0,
-      requestsThisMinute: 0,
-      tokensUsed: 0,
-      audioMinutesToday: 0,
-      lastMinuteReset: Date.now(),
-      lastDailyReset: Date.now()
-    });
-    if (tokenRefreshCallback) {
-      this.tokenRefreshCallbacks.set(tenant.tenantId, tokenRefreshCallback);
-    }
-  }
-  /**
-   * Unregister a tenant
-   */
-  unregister(tenantId) {
-    this.tenants.delete(tenantId);
-    this.quotas.delete(tenantId);
-    this.usage.delete(tenantId);
-    this.tokenRefreshCallbacks.delete(tenantId);
-  }
-  /**
-   * Get tenant config
-   */
-  get(tenantId) {
-    return this.tenants.get(tenantId);
-  }
-  /**
-   * Check if tenant exists
-   */
-  has(tenantId) {
-    return this.tenants.has(tenantId);
-  }
-  /**
-   * Get all tenant IDs
-   */
-  getTenantIds() {
-    return Array.from(this.tenants.keys());
-  }
-  /**
-   * Check if tenant can create new session
-   */
-  canCreateSession(tenantId) {
-    const quota = this.quotas.get(tenantId);
-    const usage = this.usage.get(tenantId);
-    if (!quota || !usage) return false;
-    return usage.currentSessions < quota.maxSessions;
-  }
-  /**
-   * Check if tenant can make request
-   */
-  canMakeRequest(tenantId) {
-    const quota = this.quotas.get(tenantId);
-    const usage = this.usage.get(tenantId);
-    if (!quota || !usage) return false;
-    this.checkMinuteReset(tenantId);
-    return usage.requestsThisMinute < quota.requestsPerMinute;
-  }
-  /**
-   * Check if tenant can use audio
-   */
-  canUseAudio(tenantId, minutes) {
-    const quota = this.quotas.get(tenantId);
-    const usage = this.usage.get(tenantId);
-    if (!quota || !usage) return false;
-    this.checkDailyReset(tenantId);
-    return usage.audioMinutesToday + minutes <= quota.maxAudioMinutesPerDay;
-  }
-  /**
-   * Increment session count
-   */
-  incrementSessions(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (usage) {
-      usage.currentSessions++;
-    }
-  }
-  /**
-   * Decrement session count
-   */
-  decrementSessions(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (usage && usage.currentSessions > 0) {
-      usage.currentSessions--;
-    }
-  }
-  /**
-   * Record a request
-   */
-  recordRequest(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (usage) {
-      this.checkMinuteReset(tenantId);
-      usage.requestsThisMinute++;
-    }
-  }
-  /**
-   * Record token usage
-   */
-  recordTokens(tenantId, tokens) {
-    const usage = this.usage.get(tenantId);
-    if (usage) {
-      usage.tokensUsed += tokens;
-    }
-  }
-  /**
-   * Record audio usage
-   */
-  recordAudioMinutes(tenantId, minutes) {
-    const usage = this.usage.get(tenantId);
-    if (usage) {
-      this.checkDailyReset(tenantId);
-      usage.audioMinutesToday += minutes;
-    }
-  }
-  /**
-   * Get fresh auth token for tenant
-   */
-  async getAuthToken(tenantId) {
-    const tenant = this.tenants.get(tenantId);
-    if (!tenant) {
-      throw new Error(`Tenant not found: ${tenantId}`);
-    }
-    const callback = this.tokenRefreshCallbacks.get(tenantId);
-    if (callback) {
-      const token = await callback();
-      tenant.credentials.authToken = token;
-      return token;
-    }
-    if (tenant.credentials.authToken) {
-      return tenant.credentials.authToken;
-    }
-    throw new Error(`No auth token available for tenant: ${tenantId}`);
-  }
-  /**
-   * Update tenant credentials
-   */
-  updateCredentials(tenantId, credentials) {
-    const tenant = this.tenants.get(tenantId);
-    if (tenant) {
-      tenant.credentials = { ...tenant.credentials, ...credentials };
-    }
-  }
-  /**
-   * Get usage stats for tenant
-   */
-  getUsage(tenantId) {
-    return this.usage.get(tenantId);
-  }
-  /**
-   * Get quota for tenant
-   */
-  getQuota(tenantId) {
-    return this.quotas.get(tenantId);
-  }
-  /**
-   * Update quota for tenant
-   */
-  updateQuota(tenantId, quota) {
-    const existing = this.quotas.get(tenantId);
-    if (existing) {
-      this.quotas.set(tenantId, { ...existing, ...quota });
-    }
-  }
-  /**
-   * Reset all usage stats for a tenant
-   */
-  resetUsage(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (usage) {
-      usage.requestsThisMinute = 0;
-      usage.tokensUsed = 0;
-      usage.audioMinutesToday = 0;
-      usage.lastMinuteReset = Date.now();
-      usage.lastDailyReset = Date.now();
-    }
-  }
-  // ==================== Private Methods ====================
-  checkMinuteReset(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (!usage) return;
-    const now = Date.now();
-    if (now - usage.lastMinuteReset >= 6e4) {
-      usage.requestsThisMinute = 0;
-      usage.lastMinuteReset = now;
-    }
-  }
-  checkDailyReset(tenantId) {
-    const usage = this.usage.get(tenantId);
-    if (!usage) return;
-    const now = Date.now();
-    const MS_PER_DAY = 24 * 60 * 60 * 1e3;
-    if (now - usage.lastDailyReset >= MS_PER_DAY) {
-      usage.audioMinutesToday = 0;
-      usage.lastDailyReset = now;
-    }
-  }
-};
-/**
- * Default quota for new tenants
- */
-_TenantManager.DEFAULT_QUOTA = {
-  maxSessions: 10,
-  requestsPerMinute: 60,
-  maxTokensPerConversation: 1e5,
-  maxAudioMinutesPerDay: 60
-};
-var TenantManager = _TenantManager;
-
-// src/ai/utils/AudioSyncManager.ts
-var AudioSyncManager = class extends EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.bufferPosition = 0;
-    this.playbackQueue = [];
-    this.isPlaying = false;
-    this.audioContext = null;
-    this.playbackStartTime = 0;
-    this.samplesPlayed = 0;
-    this.config = {
-      sampleRate: 16e3,
-      bufferSize: 16640,
-      overlapSize: 4160,
-      maxDriftMs: 100,
-      ...config
-    };
-    this.audioBuffer = new Float32Array(this.config.bufferSize);
-  }
-  /**
-   * Initialize audio context
-   */
-  async initialize() {
-    if (!this.audioContext) {
-      this.audioContext = new AudioContext({ sampleRate: this.config.sampleRate });
-    }
-    if (this.audioContext.state === "suspended") {
-      await this.audioContext.resume();
-    }
-  }
-  /**
-   * Push audio chunk for processing and playback
-   */
-  pushAudio(audio) {
-    this.playbackQueue.push(audio);
-    this.bufferForInference(audio);
-    if (!this.isPlaying && this.playbackQueue.length > 0) {
-      this.startPlayback();
-    }
-  }
-  /**
-   * Buffer audio for inference
-   */
-  bufferForInference(audio) {
-    let offset = 0;
-    while (offset < audio.length) {
-      const remaining = this.config.bufferSize - this.bufferPosition;
-      const toCopy = Math.min(remaining, audio.length - offset);
-      this.audioBuffer.set(audio.subarray(offset, offset + toCopy), this.bufferPosition);
-      this.bufferPosition += toCopy;
-      offset += toCopy;
-      if (this.bufferPosition >= this.config.bufferSize) {
-        this.emit("buffer.ready", { audio: new Float32Array(this.audioBuffer) });
-        const overlapStart = this.config.bufferSize - this.config.overlapSize;
-        this.audioBuffer.copyWithin(0, overlapStart);
-        this.bufferPosition = this.config.overlapSize;
-      }
-    }
-  }
-  /**
-   * Start audio playback
-   */
-  async startPlayback() {
-    if (!this.audioContext || this.isPlaying) return;
-    this.isPlaying = true;
-    this.playbackStartTime = this.audioContext.currentTime;
-    this.samplesPlayed = 0;
-    this.emit("playback.start", {});
-    await this.processPlaybackQueue();
-  }
-  /**
-   * Process playback queue
-   */
-  async processPlaybackQueue() {
-    if (!this.audioContext) return;
-    while (this.playbackQueue.length > 0) {
-      const audio = this.playbackQueue.shift();
-      const buffer = this.audioContext.createBuffer(1, audio.length, this.config.sampleRate);
-      buffer.copyToChannel(audio, 0);
-      const source = this.audioContext.createBufferSource();
-      source.buffer = buffer;
-      source.connect(this.audioContext.destination);
-      const playTime = this.playbackStartTime + this.samplesPlayed / this.config.sampleRate;
-      source.start(playTime);
-      this.samplesPlayed += audio.length;
-      this.checkDrift();
-      await new Promise((resolve) => {
-        source.onended = resolve;
-      });
-    }
-    this.isPlaying = false;
-    this.emit("playback.end", {});
-  }
-  /**
-   * Check for audio/animation drift
-   */
-  checkDrift() {
-    if (!this.audioContext) return;
-    const expectedTime = this.playbackStartTime + this.samplesPlayed / this.config.sampleRate;
-    const actualTime = this.audioContext.currentTime;
-    const driftMs = (actualTime - expectedTime) * 1e3;
-    if (Math.abs(driftMs) > this.config.maxDriftMs) {
-      this.emit("sync.drift", { driftMs });
-    }
-  }
-  /**
-   * Clear playback queue
-   */
-  clearQueue() {
-    this.playbackQueue = [];
-    this.bufferPosition = 0;
-    this.audioBuffer.fill(0);
-  }
-  /**
-   * Stop playback
-   */
-  stop() {
-    this.clearQueue();
-    this.isPlaying = false;
-  }
-  /**
-   * Get current playback position in seconds
-   */
-  getPlaybackPosition() {
-    if (!this.audioContext) return 0;
-    return this.audioContext.currentTime - this.playbackStartTime;
-  }
-  /**
-   * Check if currently playing
-   */
-  getIsPlaying() {
-    return this.isPlaying;
-  }
-  /**
-   * Dispose resources
-   */
-  dispose() {
-    this.stop();
-    this.audioContext?.close();
-    this.audioContext = null;
-  }
-};
-
-// src/ai/utils/InterruptionHandler.ts
-var InterruptionHandler = class extends EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.isSpeaking = false;
-    this.speechStartTime = 0;
-    this.lastSpeechTime = 0;
-    this.silenceTimer = null;
-    this.aiIsSpeaking = false;
-    // Debouncing: only emit one interruption per speech session
-    this.interruptionTriggeredThisSession = false;
-    this.config = {
-      vadThreshold: 0.5,
-      // Silero VAD default
-      minSpeechDurationMs: 200,
-      // Google/Amazon barge-in standard
-      silenceTimeoutMs: 500,
-      // OpenAI Realtime API standard
-      enabled: true,
-      ...config
-    };
-  }
-  /**
-   * Process VAD result for interruption detection
-   * @param vadProbability - Speech probability from VAD (0-1)
-   * @param audioEnergy - Optional RMS energy for logging (default: 0)
-   */
-  processVADResult(vadProbability, audioEnergy = 0) {
-    if (!this.config.enabled) return;
-    if (vadProbability > this.config.vadThreshold) {
-      this.onSpeechDetected(audioEnergy || vadProbability);
-    } else {
-      this.onSilenceDetected();
-    }
-  }
-  /**
-   * Notify that AI started speaking
-   */
-  setAISpeaking(speaking) {
-    this.aiIsSpeaking = speaking;
-  }
-  /**
-   * Enable/disable interruption detection
-   */
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-    if (!enabled) {
-      this.reset();
-    }
-  }
-  /**
-   * Update configuration
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * Reset state
-   */
-  reset() {
-    this.isSpeaking = false;
-    this.speechStartTime = 0;
-    this.lastSpeechTime = 0;
-    this.interruptionTriggeredThisSession = false;
-    if (this.silenceTimer) {
-      clearTimeout(this.silenceTimer);
-      this.silenceTimer = null;
-    }
-  }
-  /**
-   * Get current state
-   */
-  getState() {
-    return {
-      isSpeaking: this.isSpeaking,
-      speechDurationMs: this.isSpeaking ? Date.now() - this.speechStartTime : 0
-    };
-  }
-  // ==================== Private Methods ====================
-  onSpeechDetected(rms) {
-    const now = Date.now();
-    this.lastSpeechTime = now;
-    if (this.silenceTimer) {
-      clearTimeout(this.silenceTimer);
-      this.silenceTimer = null;
-    }
-    if (!this.isSpeaking) {
-      this.isSpeaking = true;
-      this.speechStartTime = now;
-      this.emit("speech.detected", { rms });
-    }
-    if (this.aiIsSpeaking && !this.interruptionTriggeredThisSession) {
-      const speechDuration = now - this.speechStartTime;
-      if (speechDuration >= this.config.minSpeechDurationMs) {
-        this.interruptionTriggeredThisSession = true;
-        this.emit("interruption.triggered", { rms, durationMs: speechDuration });
-      }
-    }
-  }
-  onSilenceDetected() {
-    if (!this.isSpeaking) return;
-    if (!this.silenceTimer) {
-      this.silenceTimer = setTimeout(() => {
-        const durationMs = this.lastSpeechTime - this.speechStartTime;
-        this.isSpeaking = false;
-        this.silenceTimer = null;
-        this.interruptionTriggeredThisSession = false;
-        this.emit("speech.ended", { durationMs });
-      }, this.config.silenceTimeoutMs);
-    }
-  }
-};
-
 // src/animation/types.ts
 var DEFAULT_ANIMATION_CONFIG = {
   initialState: "idle",