@absolutejs/voice 0.0.22-beta.308 → 0.0.22-beta.309

package/README.md

@@ -3525,7 +3525,7 @@ const report = await runTTSAdapterFixture(
 
 For server-to-server use, realtime adapters open provider-specific streaming connections, send session configuration, stream text or PCM input, and emit normalized transcript/audio/error/close events. OpenAI Realtime uses raw 24kHz mono `pcm_s16le` audio. The main `voice(...)` route can run in cascaded mode with `stt` plus optional `tts`, or direct realtime mode with `realtime`. Browser demos should make sure the captured PCM format matches `realtimeInputFormat` or resample before sending audio.
 
-Use `createVoiceRealtimeProviderContractMatrixPreset(...)` to prove which realtime providers are production-ready. Pipecat is represented as an explicit bridge seam by default, not core-owned media infrastructure:
+Use `createVoiceRealtimeProviderContractMatrixPreset(...)` to prove which realtime providers are production-ready. Native media-pipeline primitives such as `VoiceMediaFrame` and `buildVoiceMediaPipelineCalibrationReport(...)` are the path for advanced pipeline behavior in AbsoluteJS apps.
 
 ```ts
 import {

package/dist/index.d.ts

@@ -15,6 +15,8 @@ export type { VoiceRealtimeChannelAssertionInput, VoiceRealtimeChannelAssertionR
 export { assertVoiceRealtimeProviderContractEvidence, buildVoiceRealtimeProviderContractMatrix, createVoiceRealtimeProviderContractMatrixPreset, createVoiceRealtimeProviderContractRoutes, evaluateVoiceRealtimeProviderContractEvidence, renderVoiceRealtimeProviderContractHTML } from './realtimeProviderContracts';
 export type { VoiceRealtimeProviderContractAssertionInput, VoiceRealtimeProviderContractAssertionReport, VoiceRealtimeProviderContractCapability, VoiceRealtimeProviderContractCheck, VoiceRealtimeProviderContractDefinition, VoiceRealtimeProviderContractMatrixPresetOptions, VoiceRealtimeProviderContractMatrixInput, VoiceRealtimeProviderContractMatrixReport, VoiceRealtimeProviderContractRoutesOptions, VoiceRealtimeProviderContractRow, VoiceRealtimeProviderPresetProvider, VoiceRealtimeProviderContractStatus } from './realtimeProviderContracts';
 export { buildVoiceDiagnosticsMarkdown, createVoiceDiagnosticsRoutes, resolveVoiceDiagnosticsTraceFilter } from './diagnosticsRoutes';
+export { buildVoiceMediaPipelineCalibrationReport, createVoiceMediaFrame } from './mediaPipeline';
+export type { VoiceMediaFrame, VoiceMediaFrameKind, VoiceMediaFrameSource, VoiceMediaPipelineCalibrationInput, VoiceMediaPipelineCalibrationIssue, VoiceMediaPipelineCalibrationReport, VoiceMediaPipelineStatus } from './mediaPipeline';
 export { buildVoiceDemoReadyReport, createVoiceDemoReadyRoutes, renderVoiceDemoReadyHTML } from './demoReadyRoutes';
 export { buildVoiceDeliverySinkReport, createVoiceDeliverySinkDescriptor, createVoiceDeliverySinkPair, createVoiceDeliverySinkRoutes, createVoiceFileDeliverySink, createVoicePostgresDeliverySink, createVoiceS3DeliverySink, createVoiceSQLiteDeliverySink, createVoiceWebhookDeliverySink, renderVoiceDeliverySinkHTML } from './deliverySinkRoutes';
 export { buildVoiceOpsActionHistoryReport, createVoiceOpsActionAuditRoutes, recordVoiceOpsActionAudit, renderVoiceOpsActionHistoryHTML } from './opsActionAuditRoutes';

package/dist/index.js

@@ -11253,13 +11253,11 @@ var defaultRequiredCapabilities = [
 ];
 var defaultProviderEnv = {
   "gemini-live": ["GEMINI_API_KEY"],
-  "openai-realtime": ["OPENAI_API_KEY"],
-  "pipecat-bridge": []
+  "openai-realtime": ["OPENAI_API_KEY"]
 };
 var defaultRealtimeProviders = [
   "openai-realtime",
-  "gemini-live",
-  "pipecat-bridge"
+  "gemini-live"
 ];
 var statusRank = {
   pass: 0,
@@ -11277,7 +11275,7 @@ var createVoiceRealtimeProviderContractMatrixPreset = (options = {}) => {
     contracts: providers.map((provider) => {
       const providerKey = String(provider);
       const requiredEnv = options.requiredEnv?.[providerKey] ?? defaultProviderEnv[providerKey] ?? [];
-      const implementationStatus = options.implementationStatus?.[providerKey] ?? (providerKey === "pipecat-bridge" ? "planned" : "available");
+      const implementationStatus = options.implementationStatus?.[providerKey] ?? "available";
       const configured = options.configured?.[providerKey] ?? (implementationStatus === "planned" ? false : requiredEnv.every((name) => Boolean(options.env?.[name])));
       return {
         capabilities: options.capabilities?.[providerKey] ?? defaultRequiredCapabilities,
@@ -11611,6 +11609,80 @@ var createVoiceDiagnosticsRoutes = (options) => {
   });
   return routes;
 };
+// src/mediaPipeline.ts
+var formatLabel2 = (format) => `${format.container}/${format.encoding}/${String(format.sampleRateHz)}hz/${String(format.channels)}ch`;
+var formatMatches2 = (actual, expected) => actual.container === expected.container && actual.encoding === expected.encoding && actual.sampleRateHz === expected.sampleRateHz && actual.channels === expected.channels;
+var pushIssue = (issues, severity, code, message) => {
+  issues.push({ code, message, severity });
+};
+var numericMetadata = (frame, key) => {
+  const value = frame.metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+var createVoiceMediaFrame = (frame) => frame;
+var buildVoiceMediaPipelineCalibrationReport = (input = {}) => {
+  const frames = input.frames ?? [];
+  const issues = [];
+  const inputFrames = frames.filter((frame) => frame.kind === "input-audio");
+  const assistantFrames = frames.filter((frame) => frame.kind === "assistant-audio");
+  const turnCommitFrames = frames.filter((frame) => frame.kind === "turn-commit");
+  const interruptionFrameRecords = frames.filter((frame) => frame.kind === "interruption");
+  const traceLinkedFrames = frames.filter((frame) => frame.traceEventId).length;
+  const backpressureFrames = frames.filter((frame) => Boolean(frame.metadata?.backpressure)).length;
+  const audioLatencies = assistantFrames.map((frame) => frame.latencyMs).filter((latency) => typeof latency === "number");
+  const firstAudioLatencyMs = audioLatencies.length > 0 ? Math.min(...audioLatencies) : undefined;
+  const jitterValues = frames.map((frame) => numericMetadata(frame, "jitterMs")).filter((value) => value !== undefined);
+  const jitterMs = jitterValues.length > 0 ? Math.max(...jitterValues) : undefined;
+  const inputFormat = input.inputFormat ?? inputFrames.find((frame) => frame.format)?.format;
+  const outputFormat = input.outputFormat ?? assistantFrames.find((frame) => frame.format)?.format;
+  const resamplingRequired = Boolean(input.expectedInputFormat && inputFormat && inputFormat.sampleRateHz !== input.expectedInputFormat.sampleRateHz) || Boolean(input.expectedOutputFormat && outputFormat && outputFormat.sampleRateHz !== input.expectedOutputFormat.sampleRateHz);
+  const resamplingTargetHz = resamplingRequired && input.expectedInputFormat ? input.expectedInputFormat.sampleRateHz : resamplingRequired ? input.expectedOutputFormat?.sampleRateHz : undefined;
+  if (inputFrames.length === 0) {
+    pushIssue(issues, "warning", "media.input_audio_missing", "No input audio frames were observed.");
+  }
+  if (assistantFrames.length === 0) {
+    pushIssue(issues, "warning", "media.assistant_audio_missing", "No assistant audio frames were observed.");
+  }
+  if (input.expectedInputFormat && inputFormat && !formatMatches2(inputFormat, input.expectedInputFormat)) {
+    pushIssue(issues, inputFormat.sampleRateHz === input.expectedInputFormat.sampleRateHz ? "warning" : "error", "media.input_format_mismatch", `Input format ${formatLabel2(inputFormat)} does not match expected ${formatLabel2(input.expectedInputFormat)}.`);
+  }
+  if (input.expectedOutputFormat && outputFormat && !formatMatches2(outputFormat, input.expectedOutputFormat)) {
+    pushIssue(issues, outputFormat.sampleRateHz === input.expectedOutputFormat.sampleRateHz ? "warning" : "error", "media.output_format_mismatch", `Output format ${formatLabel2(outputFormat)} does not match expected ${formatLabel2(input.expectedOutputFormat)}.`);
+  }
+  if (firstAudioLatencyMs !== undefined && input.maxFirstAudioLatencyMs !== undefined && firstAudioLatencyMs > input.maxFirstAudioLatencyMs) {
+    pushIssue(issues, "error", "media.first_audio_latency", `First audio latency ${String(firstAudioLatencyMs)}ms exceeds budget ${String(input.maxFirstAudioLatencyMs)}ms.`);
+  }
+  if (jitterMs !== undefined && input.maxJitterMs !== undefined && jitterMs > input.maxJitterMs) {
+    pushIssue(issues, "warning", "media.jitter", `Media jitter ${String(jitterMs)}ms exceeds budget ${String(input.maxJitterMs)}ms.`);
+  }
+  if (input.maxBackpressureFrames !== undefined && backpressureFrames > input.maxBackpressureFrames) {
+    pushIssue(issues, "warning", "media.backpressure", `Backpressure frame count ${String(backpressureFrames)} exceeds budget ${String(input.maxBackpressureFrames)}.`);
+  }
+  if (input.requireInterruptionFrame && interruptionFrameRecords.length === 0) {
+    pushIssue(issues, "warning", "media.interruption_missing", "No interruption frame was observed.");
+  }
+  if (input.requireTraceEvidence && traceLinkedFrames === 0) {
+    pushIssue(issues, "warning", "media.trace_evidence_missing", "No media frames were linked to trace evidence.");
+  }
+  return {
+    assistantAudioFrames: assistantFrames.length,
+    backpressureFrames,
+    checkedAt: Date.now(),
+    firstAudioLatencyMs,
+    inputAudioFrames: inputFrames.length,
+    inputFormat,
+    interruptionFrames: interruptionFrameRecords.length,
+    issues,
+    jitterMs,
+    outputFormat,
+    resamplingRequired,
+    resamplingTargetHz,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    surface: input.surface ?? "voice-media-pipeline",
+    traceLinkedFrames,
+    turnCommitFrames: turnCommitFrames.length
+  };
+};
 // src/demoReadyRoutes.ts
 import { Elysia as Elysia12 } from "elysia";
 var escapeHtml15 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
@@ -34384,6 +34456,7 @@ export {
   createVoiceMemoryAuditSinkDeliveryStore,
   createVoiceMemoryAuditEventStore,
   createVoiceMemoryAssistantMemoryStore,
+  createVoiceMediaFrame,
   createVoiceLiveOpsRoutes,
   createVoiceLiveOpsController,
   createVoiceLiveLatencyRoutes,
@@ -34532,6 +34605,7 @@ export {
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
   buildVoiceMonitorRunReport,
+  buildVoiceMediaPipelineCalibrationReport,
   buildVoiceLiveOpsControlState,
   buildVoiceLatencySLOGate,
   buildVoiceIncidentBundle,

package/dist/mediaPipeline.d.ts

@@ -0,0 +1,56 @@
+import type { AudioFormat } from './types';
+export type VoiceMediaFrameKind = 'assistant-audio' | 'input-audio' | 'interruption' | 'metadata' | 'transcript' | 'turn-commit';
+export type VoiceMediaFrameSource = 'browser' | 'provider' | 'telephony' | 'voice-runtime';
+export type VoiceMediaPipelineStatus = 'fail' | 'pass' | 'warn';
+export type VoiceMediaFrame = {
+    at?: number;
+    audio?: ArrayBuffer | ArrayBufferView;
+    durationMs?: number;
+    format?: AudioFormat;
+    id: string;
+    kind: VoiceMediaFrameKind;
+    latencyMs?: number;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    source: VoiceMediaFrameSource | (string & {});
+    traceEventId?: string;
+    turnId?: string;
+};
+export type VoiceMediaPipelineCalibrationInput = {
+    expectedInputFormat?: AudioFormat;
+    expectedOutputFormat?: AudioFormat;
+    frames?: readonly VoiceMediaFrame[];
+    inputFormat?: AudioFormat;
+    maxBackpressureFrames?: number;
+    maxFirstAudioLatencyMs?: number;
+    maxJitterMs?: number;
+    outputFormat?: AudioFormat;
+    requireInterruptionFrame?: boolean;
+    requireTraceEvidence?: boolean;
+    surface?: string;
+};
+export type VoiceMediaPipelineCalibrationIssue = {
+    code: string;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export type VoiceMediaPipelineCalibrationReport = {
+    assistantAudioFrames: number;
+    backpressureFrames: number;
+    checkedAt: number;
+    firstAudioLatencyMs?: number;
+    inputAudioFrames: number;
+    inputFormat?: AudioFormat;
+    interruptionFrames: number;
+    issues: VoiceMediaPipelineCalibrationIssue[];
+    jitterMs?: number;
+    outputFormat?: AudioFormat;
+    resamplingRequired: boolean;
+    resamplingTargetHz?: number;
+    status: VoiceMediaPipelineStatus;
+    surface: string;
+    traceLinkedFrames: number;
+    turnCommitFrames: number;
+};
+export declare const createVoiceMediaFrame: (frame: VoiceMediaFrame) => VoiceMediaFrame;
+export declare const buildVoiceMediaPipelineCalibrationReport: (input?: VoiceMediaPipelineCalibrationInput) => VoiceMediaPipelineCalibrationReport;

package/dist/realtimeProviderContracts.d.ts

@@ -17,7 +17,7 @@ export type VoiceRealtimeProviderContractDefinition<TProvider extends string = s
     selected?: boolean;
     traceHref?: string;
 };
-export type VoiceRealtimeProviderPresetProvider = 'gemini-live' | 'openai-realtime' | 'pipecat-bridge' | (string & {});
+export type VoiceRealtimeProviderPresetProvider = 'gemini-live' | 'openai-realtime' | (string & {});
 export type VoiceRealtimeProviderContractMatrixPresetOptions<TProvider extends string = VoiceRealtimeProviderPresetProvider> = {
     capabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
     configured?: Record<string, boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.308",
+	"version": "0.0.22-beta.309",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",