@absolutejs/voice 0.0.22-beta.13 → 0.0.22-beta.131

package/dist/angular/index.js

@@ -69,9 +69,298 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
-// src/angular/voice-stream.service.ts
+// src/angular/voice-ops-status.service.ts
 import { computed, Injectable, signal } from "@angular/core";
 
+// src/client/opsStatus.ts
+var fetchVoiceOpsStatus = async (path = "/api/voice/ops-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice ops status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceOpsStatusStore = (path = "/api/voice/ops-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceOpsStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-ops-status.service.ts
+var _dec = [
+  Injectable({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceOpsStatusService {
+  connect(path = "/api/voice/ops-status", options = {}) {
+    const store = createVoiceOpsStatusStore(path, options);
+    const errorSignal = signal(null);
+    const isLoadingSignal = signal(false);
+    const reportSignal = signal(undefined);
+    const updatedAtSignal = signal(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed(() => errorSignal()),
+      isLoading: computed(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed(() => reportSignal()),
+      updatedAt: computed(() => updatedAtSignal())
+    };
+  }
+}
+VoiceOpsStatusService = __decorateElement(_init, 0, "VoiceOpsStatusService", _dec, VoiceOpsStatusService);
+__runInitializers(_init, 1, VoiceOpsStatusService);
+__decoratorMetadata(_init, VoiceOpsStatusService);
+let _VoiceOpsStatusService = VoiceOpsStatusService;
+// src/angular/voice-campaign-dialer-proof.service.ts
+import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+
+// src/client/campaignDialerProof.ts
+var fetchVoiceCampaignDialerProofStatus = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var runVoiceCampaignDialerProofAction = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceCampaignDialerProofStore = (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.status;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const status = await fetchVoiceCampaignDialerProofStatus(path, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        status,
+        updatedAt: Date.now()
+      };
+      emit();
+      return status;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const runProof = async () => {
+    const runPath = options.runPath ?? snapshot.status?.runPath ?? path;
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await runVoiceCampaignDialerProofAction(runPath, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        report,
+        status: {
+          generatedAt: Date.now(),
+          mode: report.mode,
+          ok: report.ok,
+          providers: report.providers.map((provider) => provider.provider),
+          runPath,
+          safe: true
+        },
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    runProof,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-campaign-dialer-proof.service.ts
+var _dec = [
+  Injectable2({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceCampaignDialerProofService {
+  connect(path = "/api/voice/campaigns/dialer-proof", options = {}) {
+    const store = createVoiceCampaignDialerProofStore(path, options);
+    const errorSignal = signal2(null);
+    const isLoadingSignal = signal2(false);
+    const reportSignal = signal2(undefined);
+    const statusSignal = signal2(undefined);
+    const updatedAtSignal = signal2(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      statusSignal.set(snapshot.status);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed2(() => errorSignal()),
+      isLoading: computed2(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed2(() => reportSignal()),
+      runProof: store.runProof,
+      status: computed2(() => statusSignal()),
+      updatedAt: computed2(() => updatedAtSignal())
+    };
+  }
+}
+VoiceCampaignDialerProofService = __decorateElement(_init, 0, "VoiceCampaignDialerProofService", _dec, VoiceCampaignDialerProofService);
+__runInitializers(_init, 1, VoiceCampaignDialerProofService);
+__decoratorMetadata(_init, VoiceCampaignDialerProofService);
+let _VoiceCampaignDialerProofService = VoiceCampaignDialerProofService;
+// src/angular/voice-stream.service.ts
+import { computed as computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
+
 // src/client/actions.ts
 var normalizeErrorMessage = (value) => {
   if (typeof value === "string" && value.trim()) {
@@ -120,6 +409,17 @@ var serverMessageToAction = (message) => {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "connection":
+      return {
+        reconnect: message.reconnect,
+        type: "connection"
+      };
+    case "call_lifecycle":
+      return {
+        event: message.event,
+        sessionId: message.sessionId,
+        type: "call_lifecycle"
+      };
     case "error":
       return {
         message: normalizeErrorMessage(message.message),
@@ -135,6 +435,17 @@ var serverMessageToAction = (message) => {
         transcript: message.transcript,
         type: "partial"
       };
+    case "replay":
+      return {
+        assistantTexts: message.assistantTexts,
+        call: message.call,
+        partial: message.partial,
+        scenarioId: message.scenarioId,
+        sessionId: message.sessionId,
+        status: message.status,
+        turns: message.turns,
+        type: "replay"
+      };
     case "session":
       return {
         sessionId: message.sessionId,
@@ -163,7 +474,7 @@ var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
 var noop = () => {};
 var noopUnsubscribe = () => noop;
 var NOOP_CONNECTION = {
-  start: () => {},
+  callControl: noop,
   close: noop,
   endTurn: noop,
   getReadyState: () => WS_CLOSED,
@@ -171,6 +482,7 @@ var NOOP_CONNECTION = {
   getSessionId: () => "",
   send: noop,
   sendAudio: noop,
+  start: () => {},
   subscribe: noopUnsubscribe
 };
 var createSessionId = () => crypto.randomUUID();
@@ -192,11 +504,14 @@ var isVoiceServerMessage = (value) => {
   switch (value.type) {
     case "audio":
     case "assistant":
+    case "call_lifecycle":
     case "complete":
+    case "connection":
     case "error":
     case "final":
     case "partial":
     case "pong":
+    case "replay":
     case "session":
     case "turn":
       return true;
@@ -233,6 +548,9 @@ var createVoiceConnection = (path, options = {}) => {
     sessionId: options.sessionId ?? createSessionId(),
     ws: null
   };
+  const emitConnection = (reconnect) => {
+    listeners.forEach((listener) => listener(reconnect));
+  };
   const clearTimers = () => {
     if (state.pingInterval) {
       clearInterval(state.pingInterval);
@@ -255,9 +573,28 @@ var createVoiceConnection = (path, options = {}) => {
     }
   };
   const scheduleReconnect = () => {
+    const nextAttemptAt = Date.now() + RECONNECT_DELAY_MS;
     state.reconnectAttempts += 1;
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        lastDisconnectAt: Date.now(),
+        maxAttempts: maxReconnectAttempts,
+        nextAttemptAt,
+        status: "reconnecting"
+      },
+      type: "connection"
+    });
     state.reconnectTimeout = setTimeout(() => {
       if (state.reconnectAttempts > maxReconnectAttempts) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
         return;
       }
       connect();
@@ -267,9 +604,21 @@ var createVoiceConnection = (path, options = {}) => {
     const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
     ws.binaryType = "arraybuffer";
     ws.onopen = () => {
+      const wasReconnecting = state.reconnectAttempts > 0;
       state.isConnected = true;
-      state.reconnectAttempts = 0;
       flushPendingMessages();
+      if (wasReconnecting) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastResumedAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "resumed"
+          },
+          type: "connection"
+        });
+        state.reconnectAttempts = 0;
+      }
       listeners.forEach((listener) => listener({
         scenarioId: state.scenarioId ?? undefined,
         sessionId: state.sessionId,
@@ -299,6 +648,16 @@ var createVoiceConnection = (path, options = {}) => {
       const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
       if (reconnectable) {
         scheduleReconnect();
+      } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastDisconnectAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
       }
     };
     state.ws = ws;
@@ -332,6 +691,12 @@ var createVoiceConnection = (path, options = {}) => {
   const endTurn = () => {
     send({ type: "end_turn" });
   };
+  const callControl = (message) => {
+    send({
+      ...message,
+      type: "call_control"
+    });
+  };
   const close = () => {
     clearTimers();
     if (state.ws) {
@@ -349,7 +714,7 @@ var createVoiceConnection = (path, options = {}) => {
   };
   connect();
   return {
-    start,
+    callControl,
     close,
     endTurn,
     getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
@@ -357,18 +722,26 @@ var createVoiceConnection = (path, options = {}) => {
     getSessionId: () => state.sessionId,
     send,
     sendAudio,
+    start,
     subscribe
   };
 };
 
 // src/client/store.ts
+var createInitialReconnectState = () => ({
+  attempts: 0,
+  maxAttempts: 0,
+  status: "idle"
+});
 var createInitialState = () => ({
   assistantAudio: [],
   assistantTexts: [],
+  call: null,
   error: null,
   isConnected: false,
   scenarioId: null,
   partial: "",
+  reconnect: createInitialReconnectState(),
   sessionId: null,
   status: "idle",
   turns: []
@@ -408,10 +781,36 @@ var createVoiceStreamStore = () => {
           status: "completed"
         };
         break;
+      case "call_lifecycle":
+        state = {
+          ...state,
+          call: {
+            ...state.call,
+            disposition: action.event.type === "end" ? action.event.disposition : state.call?.disposition,
+            endedAt: action.event.type === "end" ? action.event.at : state.call?.endedAt,
+            events: [...state.call?.events ?? [], action.event],
+            lastEventAt: action.event.at,
+            startedAt: state.call?.startedAt ?? action.event.at
+          },
+          sessionId: action.sessionId
+        };
+        break;
       case "connected":
         state = {
           ...state,
-          isConnected: true
+          isConnected: true,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect
+        };
+        break;
+      case "connection":
+        state = {
+          ...state,
+          reconnect: action.reconnect
         };
         break;
       case "disconnected":
@@ -439,6 +838,26 @@ var createVoiceStreamStore = () => {
           partial: action.transcript.text
         };
         break;
+      case "replay":
+        state = {
+          ...state,
+          assistantTexts: [...action.assistantTexts],
+          call: action.call ?? null,
+          error: null,
+          isConnected: action.status === "active",
+          partial: action.partial,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          sessionId: action.sessionId,
+          status: action.status,
+          turns: [...action.turns]
+        };
+        break;
       case "session":
         state = {
           ...state,
@@ -494,6 +913,9 @@ var createVoiceStream = (path, options = {}) => {
     }
   });
   return {
+    callControl(message) {
+      connection.callControl(message);
+    },
     close() {
       unsubscribeConnection();
       connection.close();
@@ -522,6 +944,9 @@ var createVoiceStream = (path, options = {}) => {
     get partial() {
       return store.getSnapshot().partial;
     },
+    get reconnect() {
+      return store.getSnapshot().reconnect;
+    },
     get sessionId() {
       return connection.getSessionId();
     },
@@ -537,6 +962,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantAudio() {
       return store.getSnapshot().assistantAudio;
     },
+    get call() {
+      return store.getSnapshot().call;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -551,27 +979,31 @@ var createVoiceStream = (path, options = {}) => {
 
 // src/angular/voice-stream.service.ts
 var _dec = [
-  Injectable({ providedIn: "root" })
+  Injectable3({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
 class VoiceStreamService {
   connect(path, options = {}) {
     const stream = createVoiceStream(path, options);
-    const assistantAudioSignal = signal([]);
-    const assistantTextsSignal = signal([]);
-    const errorSignal = signal(null);
-    const isConnectedSignal = signal(false);
-    const partialSignal = signal("");
-    const sessionIdSignal = signal(stream.sessionId);
-    const statusSignal = signal(stream.status);
-    const turnsSignal = signal([]);
+    const assistantAudioSignal = signal3([]);
+    const assistantTextsSignal = signal3([]);
+    const callSignal = signal3(null);
+    const errorSignal = signal3(null);
+    const isConnectedSignal = signal3(false);
+    const partialSignal = signal3("");
+    const reconnectSignal = signal3(stream.reconnect);
+    const sessionIdSignal = signal3(stream.sessionId);
+    const statusSignal = signal3(stream.status);
+    const turnsSignal = signal3([]);
     const sync = () => {
       assistantAudioSignal.set([...stream.assistantAudio]);
       assistantTextsSignal.set([...stream.assistantTexts]);
+      callSignal.set(stream.call);
       errorSignal.set(stream.error);
       isConnectedSignal.set(stream.isConnected);
       partialSignal.set(stream.partial);
+      reconnectSignal.set(stream.reconnect);
       sessionIdSignal.set(stream.sessionId);
       statusSignal.set(stream.status);
       turnsSignal.set([...stream.turns]);
@@ -579,20 +1011,23 @@ class VoiceStreamService {
     const unsubscribe = stream.subscribe(sync);
     sync();
     return {
-      assistantAudio: computed(() => assistantAudioSignal()),
-      assistantTexts: computed(() => assistantTextsSignal()),
+      assistantAudio: computed3(() => assistantAudioSignal()),
+      assistantTexts: computed3(() => assistantTextsSignal()),
+      call: computed3(() => callSignal()),
+      callControl: (message) => stream.callControl(message),
       close: () => {
         unsubscribe();
         stream.close();
       },
       endTurn: () => stream.endTurn(),
-      error: computed(() => errorSignal()),
-      isConnected: computed(() => isConnectedSignal()),
-      partial: computed(() => partialSignal()),
+      error: computed3(() => errorSignal()),
+      isConnected: computed3(() => isConnectedSignal()),
+      partial: computed3(() => partialSignal()),
+      reconnect: computed3(() => reconnectSignal()),
       sendAudio: (audio) => stream.sendAudio(audio),
-      sessionId: computed(() => sessionIdSignal()),
-      status: computed(() => statusSignal()),
-      turns: computed(() => turnsSignal())
+      sessionId: computed3(() => sessionIdSignal()),
+      status: computed3(() => statusSignal()),
+      turns: computed3(() => turnsSignal())
     };
   }
 }
@@ -601,7 +1036,7 @@ __runInitializers(_init, 1, VoiceStreamService);
 __decoratorMetadata(_init, VoiceStreamService);
 let _VoiceStreamService = VoiceStreamService;
 // src/angular/voice-controller.service.ts
-import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+import { computed as computed4, Injectable as Injectable4, signal as signal4 } from "@angular/core";
 
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
@@ -1065,10 +1500,12 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 var createInitialState2 = (stream) => ({
   assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
+  call: stream.call,
   error: stream.error,
   isConnected: stream.isConnected,
   isRecording: false,
   partial: stream.partial,
+  reconnect: stream.reconnect,
   recordingError: null,
   sessionId: stream.sessionId,
   scenarioId: stream.scenarioId,
@@ -1094,9 +1531,11 @@ var createVoiceController = (path, options = {}) => {
       ...state,
       assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
+      call: stream.call,
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
+      reconnect: stream.reconnect,
       sessionId: stream.sessionId,
       scenarioId: stream.scenarioId,
       status: stream.status,
@@ -1121,7 +1560,13 @@ var createVoiceController = (path, options = {}) => {
     capture = createMicrophoneCapture({
       channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
       onLevel: options.capture?.onLevel,
-      onAudio: (audio) => stream.sendAudio(audio),
+      onAudio: (audio) => {
+        if (options.capture?.onAudio) {
+          options.capture.onAudio(audio, stream.sendAudio);
+          return;
+        }
+        stream.sendAudio(audio);
+      },
       sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
     });
     return capture;
@@ -1171,6 +1616,7 @@ var createVoiceController = (path, options = {}) => {
     bindHTMX(bindingOptions) {
       return bindVoiceHTMX(stream, bindingOptions);
     },
+    callControl: (message) => stream.callControl(message),
     close,
     endTurn: () => stream.endTurn(),
     get error() {
@@ -1190,6 +1636,9 @@ var createVoiceController = (path, options = {}) => {
     get recordingError() {
       return state.recordingError;
     },
+    get reconnect() {
+      return state.reconnect;
+    },
     sendAudio: (audio) => stream.sendAudio(audio),
     get sessionId() {
       return state.sessionId;
@@ -1223,29 +1672,33 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantAudio() {
       return state.assistantAudio;
+    },
+    get call() {
+      return state.call;
     }
   };
 };
 
 // src/angular/voice-controller.service.ts
 var _dec = [
-  Injectable2({ providedIn: "root" })
+  Injectable4({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
 class VoiceControllerService {
   connect(path, options = {}) {
     const controller = createVoiceController(path, options);
-    const assistantAudioSignal = signal2([]);
-    const assistantTextsSignal = signal2([]);
-    const errorSignal = signal2(null);
-    const isConnectedSignal = signal2(false);
-    const isRecordingSignal = signal2(false);
-    const partialSignal = signal2("");
-    const recordingErrorSignal = signal2(null);
-    const sessionIdSignal = signal2(controller.sessionId);
-    const statusSignal = signal2(controller.status);
-    const turnsSignal = signal2([]);
+    const assistantAudioSignal = signal4([]);
+    const assistantTextsSignal = signal4([]);
+    const errorSignal = signal4(null);
+    const isConnectedSignal = signal4(false);
+    const isRecordingSignal = signal4(false);
+    const partialSignal = signal4("");
+    const reconnectSignal = signal4(controller.reconnect);
+    const recordingErrorSignal = signal4(null);
+    const sessionIdSignal = signal4(controller.sessionId);
+    const statusSignal = signal4(controller.status);
+    const turnsSignal = signal4([]);
     const sync = () => {
       assistantAudioSignal.set([...controller.assistantAudio]);
       assistantTextsSignal.set([...controller.assistantTexts]);
@@ -1253,6 +1706,7 @@ class VoiceControllerService {
       isConnectedSignal.set(controller.isConnected);
       isRecordingSignal.set(controller.isRecording);
       partialSignal.set(controller.partial);
+      reconnectSignal.set(controller.reconnect);
       recordingErrorSignal.set(controller.recordingError);
       sessionIdSignal.set(controller.sessionId);
       statusSignal.set(controller.status);
@@ -1261,26 +1715,27 @@ class VoiceControllerService {
     const unsubscribe = controller.subscribe(sync);
     sync();
     return {
-      assistantAudio: computed2(() => assistantAudioSignal()),
-      assistantTexts: computed2(() => assistantTextsSignal()),
+      assistantAudio: computed4(() => assistantAudioSignal()),
+      assistantTexts: computed4(() => assistantTextsSignal()),
       bindHTMX: controller.bindHTMX,
       close: () => {
         unsubscribe();
         controller.close();
       },
       endTurn: () => controller.endTurn(),
-      error: computed2(() => errorSignal()),
-      isConnected: computed2(() => isConnectedSignal()),
-      isRecording: computed2(() => isRecordingSignal()),
-      partial: computed2(() => partialSignal()),
-      recordingError: computed2(() => recordingErrorSignal()),
+      error: computed4(() => errorSignal()),
+      isConnected: computed4(() => isConnectedSignal()),
+      isRecording: computed4(() => isRecordingSignal()),
+      partial: computed4(() => partialSignal()),
+      reconnect: computed4(() => reconnectSignal()),
+      recordingError: computed4(() => recordingErrorSignal()),
       sendAudio: (audio) => controller.sendAudio(audio),
-      sessionId: computed2(() => sessionIdSignal()),
+      sessionId: computed4(() => sessionIdSignal()),
       startRecording: () => controller.startRecording(),
-      status: computed2(() => statusSignal()),
+      status: computed4(() => statusSignal()),
       stopRecording: () => controller.stopRecording(),
       toggleRecording: () => controller.toggleRecording(),
-      turns: computed2(() => turnsSignal())
+      turns: computed4(() => turnsSignal())
     };
   }
 }
@@ -1288,7 +1743,900 @@ VoiceControllerService = __decorateElement(_init, 0, "VoiceControllerService", _
 __runInitializers(_init, 1, VoiceControllerService);
 __decoratorMetadata(_init, VoiceControllerService);
 let _VoiceControllerService = VoiceControllerService;
+// src/angular/voice-provider-capabilities.service.ts
+import { computed as computed5, Injectable as Injectable5, signal as signal5 } from "@angular/core";
+
+// src/client/providerCapabilities.ts
+var fetchVoiceProviderCapabilities = async (path = "/api/provider-capabilities", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider capabilities failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderCapabilitiesStore = (path = "/api/provider-capabilities", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceProviderCapabilities(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-capabilities.service.ts
+var _dec = [
+  Injectable5({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderCapabilitiesService {
+  connect(path = "/api/provider-capabilities", options = {}) {
+    const store = createVoiceProviderCapabilitiesStore(path, options);
+    const errorSignal = signal5(null);
+    const isLoadingSignal = signal5(false);
+    const reportSignal = signal5(undefined);
+    const updatedAtSignal = signal5(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed5(() => errorSignal()),
+      isLoading: computed5(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed5(() => reportSignal()),
+      updatedAt: computed5(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderCapabilitiesService = __decorateElement(_init, 0, "VoiceProviderCapabilitiesService", _dec, VoiceProviderCapabilitiesService);
+__runInitializers(_init, 1, VoiceProviderCapabilitiesService);
+__decoratorMetadata(_init, VoiceProviderCapabilitiesService);
+let _VoiceProviderCapabilitiesService = VoiceProviderCapabilitiesService;
+// src/angular/voice-provider-status.service.ts
+import { computed as computed6, Injectable as Injectable6, signal as signal6 } from "@angular/core";
+
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-status.service.ts
+var _dec = [
+  Injectable6({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderStatusService {
+  connect(path = "/api/provider-status", options = {}) {
+    const store = createVoiceProviderStatusStore(path, options);
+    const errorSignal = signal6(null);
+    const isLoadingSignal = signal6(false);
+    const providersSignal = signal6([]);
+    const updatedAtSignal = signal6(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      providersSignal.set([...snapshot.providers]);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed6(() => errorSignal()),
+      isLoading: computed6(() => isLoadingSignal()),
+      providers: computed6(() => providersSignal()),
+      refresh: store.refresh,
+      updatedAt: computed6(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderStatusService = __decorateElement(_init, 0, "VoiceProviderStatusService", _dec, VoiceProviderStatusService);
+__runInitializers(_init, 1, VoiceProviderStatusService);
+__decoratorMetadata(_init, VoiceProviderStatusService);
+let _VoiceProviderStatusService = VoiceProviderStatusService;
+// src/angular/voice-routing-status.service.ts
+import { Injectable as Injectable7, signal as signal7 } from "@angular/core";
+
+// src/client/routingStatus.ts
+var fetchVoiceRoutingStatus = async (path = "/api/routing/latest", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice routing status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceRoutingStatusStore = (path = "/api/routing/latest", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    decision: null,
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.decision;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const decision = await fetchVoiceRoutingStatus(path, options);
+      snapshot = {
+        decision,
+        error: null,
+        isLoading: false,
+        updatedAt: Date.now()
+      };
+      emit();
+      return decision;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-routing-status.service.ts
+var _dec = [
+  Injectable7({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceRoutingStatusService {
+  connect(path = "/api/routing/latest", options = {}) {
+    const store = createVoiceRoutingStatusStore(path, options);
+    const decisionSignal = signal7(null);
+    const errorSignal = signal7(null);
+    const isLoadingSignal = signal7(false);
+    const updatedAtSignal = signal7(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      decisionSignal.set(snapshot.decision);
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      decision: decisionSignal.asReadonly(),
+      error: errorSignal.asReadonly(),
+      isLoading: isLoadingSignal.asReadonly(),
+      refresh: store.refresh,
+      updatedAt: updatedAtSignal.asReadonly()
+    };
+  }
+}
+VoiceRoutingStatusService = __decorateElement(_init, 0, "VoiceRoutingStatusService", _dec, VoiceRoutingStatusService);
+__runInitializers(_init, 1, VoiceRoutingStatusService);
+__decoratorMetadata(_init, VoiceRoutingStatusService);
+let _VoiceRoutingStatusService = VoiceRoutingStatusService;
+// src/angular/voice-trace-timeline.service.ts
+import { computed as computed7, Injectable as Injectable8, signal as signal8 } from "@angular/core";
+
+// src/client/traceTimeline.ts
+var fetchVoiceTraceTimeline = async (path = "/api/voice-traces", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice trace timeline failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceTraceTimelineStore = (path = "/api/voice-traces", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    report: null
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceTraceTimeline(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-trace-timeline.service.ts
+var _dec = [
+  Injectable8({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTraceTimelineService {
+  connect(path = "/api/voice-traces", options = {}) {
+    const store = createVoiceTraceTimelineStore(path, options);
+    const errorSignal = signal8(null);
+    const isLoadingSignal = signal8(false);
+    const reportSignal = signal8(null);
+    const updatedAtSignal = signal8(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed7(() => errorSignal()),
+      isLoading: computed7(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed7(() => reportSignal()),
+      updatedAt: computed7(() => updatedAtSignal())
+    };
+  }
+}
+VoiceTraceTimelineService = __decorateElement(_init, 0, "VoiceTraceTimelineService", _dec, VoiceTraceTimelineService);
+__runInitializers(_init, 1, VoiceTraceTimelineService);
+__decoratorMetadata(_init, VoiceTraceTimelineService);
+let _VoiceTraceTimelineService = VoiceTraceTimelineService;
+// src/angular/voice-turn-latency.service.ts
+import { computed as computed8, Injectable as Injectable9, signal as signal9 } from "@angular/core";
+
+// src/client/turnLatency.ts
+var fetchVoiceTurnLatency = async (path = "/api/turn-latency", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice turn latency failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var runVoiceTurnLatencyProof = async (path, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Voice turn latency proof failed: HTTP ${response.status}`);
+  }
+  return response.json();
+};
+var createVoiceTurnLatencyStore = (path = "/api/turn-latency", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await fetchVoiceTurnLatency(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const runProof = async () => {
+    if (!options.proofPath) {
+      throw new Error("Voice turn latency proof path is not configured.");
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      await runVoiceTurnLatencyProof(options.proofPath, options);
+      return await refresh();
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    runProof,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-turn-latency.service.ts
+var _dec = [
+  Injectable9({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTurnLatencyService {
+  connect(path = "/api/turn-latency", options = {}) {
+    const store = createVoiceTurnLatencyStore(path, options);
+    const errorSignal = signal9(null);
+    const isLoadingSignal = signal9(false);
+    const reportSignal = signal9(undefined);
+    const updatedAtSignal = signal9(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed8(() => errorSignal()),
+      isLoading: computed8(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed8(() => reportSignal()),
+      runProof: store.runProof,
+      updatedAt: computed8(() => updatedAtSignal())
+    };
+  }
+}
+VoiceTurnLatencyService = __decorateElement(_init, 0, "VoiceTurnLatencyService", _dec, VoiceTurnLatencyService);
+__runInitializers(_init, 1, VoiceTurnLatencyService);
+__decoratorMetadata(_init, VoiceTurnLatencyService);
+let _VoiceTurnLatencyService = VoiceTurnLatencyService;
+// src/angular/voice-turn-quality.service.ts
+import { computed as computed9, Injectable as Injectable10, signal as signal10 } from "@angular/core";
+
+// src/client/turnQuality.ts
+var fetchVoiceTurnQuality = async (path = "/api/turn-quality", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice turn quality failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceTurnQualityStore = (path = "/api/turn-quality", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceTurnQuality(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-turn-quality.service.ts
+var _dec = [
+  Injectable10({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTurnQualityService {
+  connect(path = "/api/turn-quality", options = {}) {
+    const store = createVoiceTurnQualityStore(path, options);
+    const errorSignal = signal10(null);
+    const isLoadingSignal = signal10(false);
+    const reportSignal = signal10(undefined);
+    const updatedAtSignal = signal10(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed9(() => errorSignal()),
+      isLoading: computed9(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed9(() => reportSignal()),
+      updatedAt: computed9(() => updatedAtSignal())
+    };
+  }
+}
+VoiceTurnQualityService = __decorateElement(_init, 0, "VoiceTurnQualityService", _dec, VoiceTurnQualityService);
+__runInitializers(_init, 1, VoiceTurnQualityService);
+__decoratorMetadata(_init, VoiceTurnQualityService);
+let _VoiceTurnQualityService = VoiceTurnQualityService;
+// src/angular/voice-workflow-status.service.ts
+import { computed as computed10, Injectable as Injectable11, signal as signal11 } from "@angular/core";
+
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-workflow-status.service.ts
+var _dec = [
+  Injectable11({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceWorkflowStatusService {
+  connect(path = "/evals/scenarios/json", options = {}) {
+    const store = createVoiceWorkflowStatusStore(path, options);
+    const errorSignal = signal11(null);
+    const isLoadingSignal = signal11(false);
+    const reportSignal = signal11(undefined);
+    const updatedAtSignal = signal11(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed10(() => errorSignal()),
+      isLoading: computed10(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed10(() => reportSignal()),
+      updatedAt: computed10(() => updatedAtSignal())
+    };
+  }
+}
+VoiceWorkflowStatusService = __decorateElement(_init, 0, "VoiceWorkflowStatusService", _dec, VoiceWorkflowStatusService);
+__runInitializers(_init, 1, VoiceWorkflowStatusService);
+__decoratorMetadata(_init, VoiceWorkflowStatusService);
+let _VoiceWorkflowStatusService = VoiceWorkflowStatusService;
 export {
+  VoiceWorkflowStatusService,
+  VoiceTurnQualityService,
+  VoiceTurnLatencyService,
+  VoiceTraceTimelineService,
   VoiceStreamService,
-  VoiceControllerService
+  VoiceRoutingStatusService,
+  VoiceProviderStatusService,
+  VoiceProviderCapabilitiesService,
+  VoiceOpsStatusService,
+  VoiceControllerService,
+  VoiceCampaignDialerProofService
 };