@omote/core 0.9.7 → 0.10.6

package/README.md

@@ -14,8 +14,8 @@
 - **TTSSpeaker** — High-level speak(text) with abort, queueing, and LLM streaming
 - **SpeechListener** — Mic → VAD → ASR orchestration with adaptive silence detection
 - **createTTSPlayer()** — Factory composing Kokoro TTS + TTSSpeaker for zero-config playback
-- **VoicePipeline** — Full conversational agent loop with local TTS support (cloud or offline)
-- **configureOrtCdn()** — Enterprise CDN override for ORT WASM/WebGPU binaries
+- **VoiceOrchestrator** — Full conversational agent loop with local TTS support (cloud or offline)
+- **configureModelUrls()** — Self-host model files from your own CDN
 - **Animation Graph** — State machine (idle/listening/thinking/speaking) with emotion blending
 - **Emotion Controller** — Preset-based emotion system with smooth transitions
 - **Model Caching** — IndexedDB with versioning, LRU eviction, and quota monitoring
@@ -81,15 +81,15 @@ const { blendshapes } = await a2e.infer(audioSamples); // Float32Array (16kHz)
 // → 52 ARKit blendshape weights
 ```
 
-#### Direct API
+#### Custom Configuration
 
 ```typescript
-import { A2EInference, ARKIT_BLENDSHAPES } from '@omote/core';
+import { createA2E, ARKIT_BLENDSHAPES } from '@omote/core';
 
-const lam = new A2EInference({ modelUrl: '/models/model_fp16.onnx' });
-await lam.load();
+const a2e = createA2E({ backend: 'wasm' }); // Force WASM for testing
+await a2e.load();
 
-const { blendshapes } = await lam.infer(audioSamples);
+const { blendshapes } = await a2e.infer(audioSamples);
 const jawOpen = blendshapes[ARKIT_BLENDSHAPES.indexOf('jawOpen')];
 ```
 
@@ -136,11 +136,9 @@ const frame = processor.getFrameForTime(audioContext.currentTime);
 SenseVoice ASR — 15x faster than Whisper, with progressive transcription and emotion detection.
 
 ```typescript
-import { SenseVoiceInference } from '@omote/core';
+import { createSenseVoice } from '@omote/core';
 
-const asr = new SenseVoiceInference({
-  modelUrl: '/models/sensevoice/model.int8.onnx',
-});
+const asr = createSenseVoice(); // Auto-detects platform, fetches from HF CDN
 await asr.load();
 
 const { text, emotion, language } = await asr.transcribe(audioSamples);
@@ -149,22 +147,19 @@ const { text, emotion, language } = await asr.transcribe(audioSamples);
 #### Platform-Aware ASR
 
 ```typescript
-import { shouldUseNativeASR, SafariSpeechRecognition, SenseVoiceInference } from '@omote/core';
+import { shouldUseNativeASR, SafariSpeechRecognition, createSenseVoice } from '@omote/core';
 
 const asr = shouldUseNativeASR()
   ? new SafariSpeechRecognition({ language: 'en-US' })
-  : new SenseVoiceInference({ modelUrl: '/models/sensevoice/model.int8.onnx' });
+  : createSenseVoice();
 ```
 
 ### Voice Activity Detection (Silero VAD)
 
-#### Factory API (Recommended)
-
 ```typescript
 import { createSileroVAD } from '@omote/core';
 
 const vad = createSileroVAD({
-  modelUrl: '/models/silero-vad.onnx',
   threshold: 0.5,
   // useWorker: true   // Force off-main-thread
   // useWorker: false  // Force main thread
@@ -174,18 +169,6 @@ await vad.load();
 const { isSpeech, probability } = await vad.process(audioSamples);
 ```
 
-#### Direct API
-
-```typescript
-import { SileroVADInference, SileroVADWorker } from '@omote/core';
-
-// Main thread (mobile-friendly)
-const vad = new SileroVADInference({ modelUrl: '/models/silero-vad.onnx' });
-
-// Web Worker (desktop, off-main-thread)
-const vadWorker = new SileroVADWorker({ modelUrl: '/models/silero-vad.onnx' });
-```
-
 ### Animation Graph
 
 State machine for avatar animation states with emotion blending and audio energy.
@@ -248,7 +231,7 @@ const data = await fetchWithCache('/models/model.onnx', {
 });
 
 // Cache quota monitoring
-import { configureCacheLimit, getQuotaInfo } from '@omote/core';
+import { configureCacheLimit } from '@omote/core';
 
 configureCacheLimit({
   maxSizeBytes: 500 * 1024 * 1024, // 500MB limit
@@ -307,17 +290,76 @@ const span = telemetry.startSpan('custom-operation');
 span.end();
 ```
 
-## Models
+### Text-to-Speech (Kokoro TTS)
+
+```typescript
+import { createKokoroTTS } from '@omote/core';
 
-Place models in your public assets directory:
+const tts = createKokoroTTS({ defaultVoice: 'af_heart' });
+await tts.load();
 
+const audio = await tts.synthesize('Hello world!');
+// audio: Float32Array @ 24kHz
 ```
-public/models/
-  model_fp16.onnx                 # A2E lip sync — WebGPU (192MB fp16, from omote-ai/lam-a2e)
-  sensevoice/model.int8.onnx      # SenseVoice ASR (239MB)
-  silero-vad.onnx                 # Voice activity detection (~2MB)
+
+Kokoro auto-detects the platform: mixed-fp16 WebGPU model (156MB) on Chrome/Edge, q8 WASM model (92MB) on Safari/iOS/Firefox.
+
+### Eager Load & Warmup
+
+Use `eagerLoad` to preload models at construction time:
+
+```typescript
+const tts = createKokoroTTS({ eagerLoad: true }); // Starts loading immediately
 ```
 
+Use `warmup()` to prime AudioContext for iOS/Safari autoplay policy. Call from a user gesture handler:
+
+```typescript
+button.onclick = async () => {
+  await avatar.warmup(); // Primes AudioContext
+  await avatar.connectVoice({ ... });
+};
+```
+
+### Observability
+
+The SDK includes built-in OpenTelemetry-compatible tracing and metrics:
+
+```typescript
+import { configureTelemetry, getTelemetry, MetricNames } from '@omote/core';
+
+configureTelemetry({
+  enabled: true,
+  serviceName: 'my-app',
+  exporter: 'console', // or OTLPExporter for production
+});
+```
+
+All inference calls, model loads, cache operations, and voice turns are automatically instrumented.
+
+## Models
+
+All models default to the HuggingFace CDN and are auto-downloaded on first use. Self-host with `configureModelUrls()`:
+
+```typescript
+import { configureModelUrls } from '@omote/core';
+
+configureModelUrls({
+  lam: 'https://your-cdn.com/models/lam.onnx',
+  lamData: 'https://your-cdn.com/models/lam.onnx.data',
+  senseVoice: 'https://your-cdn.com/models/sensevoice.onnx',
+  sileroVad: 'https://your-cdn.com/models/silero_vad.onnx',
+});
+```
+
+| Model | HuggingFace Repo | Size |
+|-------|-------------------|------|
+| LAM A2E | `omote-ai/lam-a2e` | `lam.onnx` (230KB) + `lam.onnx.data` (192MB) |
+| SenseVoice | `omote-ai/sensevoice-asr` | 228MB |
+| Silero VAD | `deepghs/silero-vad-onnx` | ~2MB |
+| Kokoro TTS (WASM) | `onnx-community/Kokoro-82M-v1.0-ONNX` | 92MB q8 |
+| Kokoro TTS (WebGPU) | `omote-ai/kokoro-tts` | 156MB mixed-fp16 |
+
 ## Browser Compatibility
 
 WebGPU-first with automatic WASM fallback.

package/dist/{chunk-X5OTUOE6.mjs → chunk-3FILA2CD.mjs}

@@ -82,6 +82,8 @@ var jsonFormatter = (entry) => {
   if (entry.data && Object.keys(entry.data).length > 0) {
     output.data = entry.data;
   }
+  if (entry.traceId) output.traceId = entry.traceId;
+  if (entry.spanId) output.spanId = entry.spanId;
   if (entry.error) {
     output.error = {
       name: entry.error.name,
@@ -103,6 +105,9 @@ var prettyFormatter = (entry) => {
     const color = LEVEL_COLORS[entry.level];
     output = `${COLORS.gray}${time}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${module}]${COLORS.reset} ${message}`;
   }
+  if (entry.traceId) {
+    output += ` [trace:${entry.traceId.slice(0, 8)}]`;
+  }
   if (entry.data && Object.keys(entry.data).length > 0) {
     const dataStr = safeStringify(entry.data);
     if (dataStr.length > 80) {
@@ -207,198 +212,6 @@ var ConsoleExporter = class {
   }
 };
 
-// src/telemetry/exporters/otlp.ts
-var StatusCode = {
-  UNSET: 0,
-  OK: 1,
-  ERROR: 2
-};
-function spanToOTLP(span, serviceName, serviceVersion) {
-  const attributes = Object.entries(span.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
-    key,
-    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
-  }));
-  return {
-    resourceSpans: [{
-      resource: {
-        attributes: [
-          { key: "service.name", value: { stringValue: serviceName } },
-          { key: "service.version", value: { stringValue: serviceVersion } },
-          { key: "telemetry.sdk.name", value: { stringValue: "omote-sdk" } },
-          { key: "telemetry.sdk.language", value: { stringValue: "javascript" } }
-        ]
-      },
-      scopeSpans: [{
-        scope: {
-          name: "omote-sdk",
-          version: serviceVersion
-        },
-        spans: [{
-          traceId: span.traceId,
-          spanId: span.spanId,
-          parentSpanId: span.parentSpanId || "",
-          name: span.name,
-          kind: 1,
-          // INTERNAL
-          startTimeUnixNano: String(span.startTime * 1e6),
-          endTimeUnixNano: String(span.endTime * 1e6),
-          attributes,
-          status: {
-            code: span.status === "ok" ? StatusCode.OK : StatusCode.ERROR,
-            message: span.error?.message || ""
-          }
-        }]
-      }]
-    }]
-  };
-}
-function metricToOTLP(metric, serviceName, serviceVersion) {
-  const attributes = Object.entries(metric.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
-    key,
-    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
-  }));
-  const dataPoint = {
-    attributes,
-    timeUnixNano: String(metric.timestamp * 1e6),
-    ...metric.type === "counter" ? { asInt: metric.value } : { asDouble: metric.value }
-  };
-  return {
-    resourceMetrics: [{
-      resource: {
-        attributes: [
-          { key: "service.name", value: { stringValue: serviceName } },
-          { key: "service.version", value: { stringValue: serviceVersion } }
-        ]
-      },
-      scopeMetrics: [{
-        scope: {
-          name: "omote-sdk",
-          version: serviceVersion
-        },
-        metrics: [{
-          name: metric.name,
-          ...metric.type === "counter" ? {
-            sum: {
-              dataPoints: [dataPoint],
-              aggregationTemporality: 2,
-              // CUMULATIVE
-              isMonotonic: true
-            }
-          } : {
-            gauge: {
-              dataPoints: [dataPoint]
-            }
-          }
-        }]
-      }]
-    }]
-  };
-}
-var OTLPExporter = class {
-  constructor(config, serviceName = "omote-sdk", serviceVersion = "0.1.0") {
-    this.spanBuffer = [];
-    this.metricBuffer = [];
-    this.flushIntervalId = null;
-    this.BUFFER_SIZE = 100;
-    this.FLUSH_INTERVAL_MS = 5e3;
-    this.isShutdown = false;
-    const parsed = new URL(config.endpoint);
-    if (parsed.protocol !== "https:") {
-      const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
-      if (!isLocalhost) {
-        throw new Error("OTLP endpoint must use HTTPS (or localhost for development)");
-      }
-    }
-    this.config = {
-      endpoint: config.endpoint,
-      timeoutMs: config.timeoutMs ?? 1e4,
-      headers: config.headers ? { ...config.headers } : {}
-    };
-    this.serviceName = serviceName;
-    this.serviceVersion = serviceVersion;
-    this.flushIntervalId = setInterval(() => {
-      this.flush().catch(console.error);
-    }, this.FLUSH_INTERVAL_MS);
-  }
-  exportSpan(span) {
-    if (this.isShutdown) return;
-    this.spanBuffer.push(span);
-    if (this.spanBuffer.length >= this.BUFFER_SIZE) {
-      this.flush().catch(console.error);
-    }
-  }
-  exportMetric(metric) {
-    if (this.isShutdown) return;
-    this.metricBuffer.push(metric);
-    if (this.metricBuffer.length >= this.BUFFER_SIZE) {
-      this.flush().catch(console.error);
-    }
-  }
-  async flush() {
-    if (this.isShutdown) return;
-    const spans = this.spanBuffer.splice(0);
-    const metrics = this.metricBuffer.splice(0);
-    const promises = [];
-    if (spans.length > 0) {
-      promises.push(this.exportSpans(spans));
-    }
-    if (metrics.length > 0) {
-      promises.push(this.exportMetrics(metrics));
-    }
-    await Promise.all(promises);
-  }
-  async shutdown() {
-    if (this.flushIntervalId) {
-      clearInterval(this.flushIntervalId);
-      this.flushIntervalId = null;
-    }
-    await this.flush();
-    this.isShutdown = true;
-  }
-  async exportSpans(spans) {
-    const resourceSpans = spans.map(
-      (span) => spanToOTLP(span, this.serviceName, this.serviceVersion).resourceSpans[0]
-    );
-    const body = { resourceSpans };
-    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/traces";
-    await this.sendRequest(endpoint, body);
-  }
-  async exportMetrics(metrics) {
-    const resourceMetrics = metrics.map(
-      (metric) => metricToOTLP(metric, this.serviceName, this.serviceVersion).resourceMetrics[0]
-    );
-    const body = { resourceMetrics };
-    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/metrics";
-    await this.sendRequest(endpoint, body);
-  }
-  async sendRequest(endpoint, body) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.config.headers
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        console.warn(`[OTLP] Export failed: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      if (error.name === "AbortError") {
-        console.warn("[OTLP] Export timed out");
-      } else {
-        console.warn("[OTLP] Export error:", error);
-      }
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-
 // src/logging/Clock.ts
 var defaultClock = {
   now: () => performance.now(),
@@ -413,6 +226,7 @@ function getClock() {
 }
 
 // src/telemetry/OmoteTelemetry.ts
+var DEFAULT_HISTOGRAM_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4, 3e4, 6e4];
 function generateId(length = 16) {
   const bytes = new Uint8Array(length);
   crypto.getRandomValues(bytes);
@@ -432,6 +246,7 @@ function getTelemetry() {
 var OmoteTelemetry = class {
   constructor(config) {
     this.exporter = null;
+    this.exporterReady = null;
     this.activeTraceId = null;
     this.metricsIntervalId = null;
     // Span stack for log-to-span correlation
@@ -450,14 +265,22 @@ var OmoteTelemetry = class {
       metricsIntervalMs: config.metricsIntervalMs ?? 6e4
     };
     if (this.config.enabled) {
-      this.initExporter();
+      if (config.customExporter) {
+        this.exporter = config.customExporter;
+      } else {
+        this.exporterReady = this.initExporter();
+      }
       this.startMetricsCollection();
     }
   }
   /**
    * Initialize the configured exporter
    */
-  initExporter() {
+  async initExporter() {
+    if (this.config.customExporter) {
+      this.exporter = this.config.customExporter;
+      return;
+    }
     switch (this.config.exporter) {
       case "console":
         this.exporter = new ConsoleExporter({ enabled: true });
@@ -467,11 +290,14 @@ var OmoteTelemetry = class {
           console.warn("[Telemetry] OTLP exporter requires exporterConfig with endpoint");
           return;
         }
-        this.exporter = new OTLPExporter(
-          this.config.exporterConfig,
-          this.config.serviceName,
-          this.config.serviceVersion
-        );
+        {
+          const { OTLPExporter } = await import("./otlp-2BML6FIK.mjs");
+          this.exporter = new OTLPExporter(
+            this.config.exporterConfig,
+            this.config.serviceName,
+            this.config.serviceVersion
+          );
+        }
         break;
       case "none":
       default:
@@ -521,6 +347,7 @@ var OmoteTelemetry = class {
     const spanId = generateId(8);
     const parentSpanId = parentContext?.spanId;
     const startTime = getClock().now();
+    const epochMs = Date.now();
     if (!parentContext && !this.activeTraceId) {
       this.activeTraceId = traceId;
     }
@@ -536,6 +363,7 @@ var OmoteTelemetry = class {
       if (idx !== -1) this.spanStack.splice(idx, 1);
       const endTime = getClock().now();
       const durationMs = endTime - startTime;
+      const endEpochMs = epochMs + (endTime - startTime);
       if (status === "error" && !sampled) {
         sampled = this.shouldSample(true);
       }
@@ -548,6 +376,8 @@ var OmoteTelemetry = class {
         startTime,
         endTime,
         durationMs,
+        epochMs,
+        endEpochMs,
         status,
         attributes: spanAttributes,
         error
@@ -622,7 +452,7 @@ var OmoteTelemetry = class {
    * });
    * ```
    */
-  recordHistogram(name, value, attributes = {}) {
+  recordHistogram(name, value, attributes = {}, bucketBoundaries = DEFAULT_HISTOGRAM_BUCKETS) {
     if (!this.config.enabled || !this.config.metricsEnabled) return;
     const key = this.getMetricKey(name, attributes);
     const existing = this.histograms.get(key);
@@ -631,8 +461,27 @@ var OmoteTelemetry = class {
       existing.sum += value;
       if (value < existing.min) existing.min = value;
       if (value > existing.max) existing.max = value;
+      let placed = false;
+      for (let i = 0; i < existing.bucketBoundaries.length; i++) {
+        if (value <= existing.bucketBoundaries[i]) {
+          existing.bucketCounts[i]++;
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) existing.bucketCounts[existing.bucketCounts.length - 1]++;
     } else {
-      this.histograms.set(key, { count: 1, sum: value, min: value, max: value, attributes });
+      const bucketCounts = new Array(bucketBoundaries.length + 1).fill(0);
+      let placed = false;
+      for (let i = 0; i < bucketBoundaries.length; i++) {
+        if (value <= bucketBoundaries[i]) {
+          bucketCounts[i]++;
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) bucketCounts[bucketCounts.length - 1]++;
+      this.histograms.set(key, { count: 1, sum: value, min: value, max: value, bucketBoundaries, bucketCounts, attributes });
     }
   }
   /**
@@ -649,7 +498,7 @@ var OmoteTelemetry = class {
    */
   flushMetrics() {
     if (!this.exporter) return;
-    const timestamp = getClock().now();
+    const timestamp = Date.now();
     for (const [key, data] of this.counters) {
       if (data.value === 0) continue;
       const name = key.split("|")[0];
@@ -678,19 +527,29 @@ var OmoteTelemetry = class {
           min: data.min,
           max: data.max
         },
-        timestamp
+        timestamp,
+        histogramData: {
+          count: data.count,
+          sum: data.sum,
+          min: data.min,
+          max: data.max,
+          bucketBoundaries: [...data.bucketBoundaries],
+          bucketCounts: [...data.bucketCounts]
+        }
       };
       this.exporter.exportMetric(metric);
       data.count = 0;
       data.sum = 0;
       data.min = Infinity;
       data.max = -Infinity;
+      data.bucketCounts.fill(0);
     }
   }
   /**
    * Force flush all pending data
    */
   async flush() {
+    if (this.exporterReady) await this.exporterReady;
     this.flushMetrics();
     await this.exporter?.flush();
   }
@@ -906,7 +765,6 @@ export {
   prettyFormatter,
   getFormatter,
   ConsoleExporter,
-  OTLPExporter,
   defaultClock,
   configureClock,
   getClock,
@@ -924,4 +782,4 @@ export {
   getNoopLogger,
   ErrorCodes
 };
-//# sourceMappingURL=chunk-X5OTUOE6.mjs.map
+//# sourceMappingURL=chunk-3FILA2CD.mjs.map