@absolutejs/voice 0.0.22-beta.6 → 0.0.22-beta.61

package/dist/angular/index.js

@@ -69,9 +69,133 @@ 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-app-kit-status.service.ts
 import { computed, Injectable, signal } from "@angular/core";
 
+// src/client/appKitStatus.ts
+var fetchVoiceAppKitStatus = async (path = "/app-kit/status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice app kit status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceAppKitStatusStore = (path = "/app-kit/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 fetchVoiceAppKitStatus(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-app-kit-status.service.ts
+var _dec = [
+  Injectable({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceAppKitStatusService {
+  connect(path = "/app-kit/status", options = {}) {
+    const store = createVoiceAppKitStatusStore(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())
+    };
+  }
+}
+VoiceAppKitStatusService = __decorateElement(_init, 0, "VoiceAppKitStatusService", _dec, VoiceAppKitStatusService);
+__runInitializers(_init, 1, VoiceAppKitStatusService);
+__decoratorMetadata(_init, VoiceAppKitStatusService);
+let _VoiceAppKitStatusService = VoiceAppKitStatusService;
+// src/angular/voice-stream.service.ts
+import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+
 // src/client/actions.ts
 var normalizeErrorMessage = (value) => {
   if (typeof value === "string" && value.trim()) {
@@ -120,6 +244,12 @@ var serverMessageToAction = (message) => {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "call_lifecycle":
+      return {
+        event: message.event,
+        sessionId: message.sessionId,
+        type: "call_lifecycle"
+      };
     case "error":
       return {
         message: normalizeErrorMessage(message.message),
@@ -163,7 +293,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 +301,7 @@ var NOOP_CONNECTION = {
   getSessionId: () => "",
   send: noop,
   sendAudio: noop,
+  start: () => {},
   subscribe: noopUnsubscribe
 };
 var createSessionId = () => crypto.randomUUID();
@@ -192,6 +323,7 @@ var isVoiceServerMessage = (value) => {
   switch (value.type) {
     case "audio":
     case "assistant":
+    case "call_lifecycle":
     case "complete":
     case "error":
     case "final":
@@ -332,6 +464,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 +487,7 @@ var createVoiceConnection = (path, options = {}) => {
   };
   connect();
   return {
-    start,
+    callControl,
     close,
     endTurn,
     getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
@@ -357,6 +495,7 @@ var createVoiceConnection = (path, options = {}) => {
     getSessionId: () => state.sessionId,
     send,
     sendAudio,
+    start,
     subscribe
   };
 };
@@ -365,6 +504,7 @@ var createVoiceConnection = (path, options = {}) => {
 var createInitialState = () => ({
   assistantAudio: [],
   assistantTexts: [],
+  call: null,
   error: null,
   isConnected: false,
   scenarioId: null,
@@ -408,6 +548,20 @@ 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,
@@ -494,6 +648,9 @@ var createVoiceStream = (path, options = {}) => {
     }
   });
   return {
+    callControl(message) {
+      connection.callControl(message);
+    },
     close() {
       unsubscribeConnection();
       connection.close();
@@ -537,6 +694,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantAudio() {
       return store.getSnapshot().assistantAudio;
     },
+    get call() {
+      return store.getSnapshot().call;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -551,24 +711,26 @@ var createVoiceStream = (path, options = {}) => {
 
 // src/angular/voice-stream.service.ts
 var _dec = [
-  Injectable({ providedIn: "root" })
+  Injectable2({ 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 = signal2([]);
+    const assistantTextsSignal = signal2([]);
+    const callSignal = signal2(null);
+    const errorSignal = signal2(null);
+    const isConnectedSignal = signal2(false);
+    const partialSignal = signal2("");
+    const sessionIdSignal = signal2(stream.sessionId);
+    const statusSignal = signal2(stream.status);
+    const turnsSignal = signal2([]);
     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);
@@ -579,20 +741,22 @@ class VoiceStreamService {
     const unsubscribe = stream.subscribe(sync);
     sync();
     return {
-      assistantAudio: computed(() => assistantAudioSignal()),
-      assistantTexts: computed(() => assistantTextsSignal()),
+      assistantAudio: computed2(() => assistantAudioSignal()),
+      assistantTexts: computed2(() => assistantTextsSignal()),
+      call: computed2(() => callSignal()),
+      callControl: (message) => stream.callControl(message),
       close: () => {
         unsubscribe();
         stream.close();
       },
       endTurn: () => stream.endTurn(),
-      error: computed(() => errorSignal()),
-      isConnected: computed(() => isConnectedSignal()),
-      partial: computed(() => partialSignal()),
+      error: computed2(() => errorSignal()),
+      isConnected: computed2(() => isConnectedSignal()),
+      partial: computed2(() => partialSignal()),
       sendAudio: (audio) => stream.sendAudio(audio),
-      sessionId: computed(() => sessionIdSignal()),
-      status: computed(() => statusSignal()),
-      turns: computed(() => turnsSignal())
+      sessionId: computed2(() => sessionIdSignal()),
+      status: computed2(() => statusSignal()),
+      turns: computed2(() => turnsSignal())
     };
   }
 }
@@ -601,7 +765,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 computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
 
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
@@ -1065,6 +1229,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 var createInitialState2 = (stream) => ({
   assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
+  call: stream.call,
   error: stream.error,
   isConnected: stream.isConnected,
   isRecording: false,
@@ -1094,6 +1259,7 @@ var createVoiceController = (path, options = {}) => {
       ...state,
       assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
+      call: stream.call,
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
@@ -1171,6 +1337,7 @@ var createVoiceController = (path, options = {}) => {
     bindHTMX(bindingOptions) {
       return bindVoiceHTMX(stream, bindingOptions);
     },
+    callControl: (message) => stream.callControl(message),
     close,
     endTurn: () => stream.endTurn(),
     get error() {
@@ -1223,29 +1390,32 @@ 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" })
+  Injectable3({ 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 = signal3([]);
+    const assistantTextsSignal = signal3([]);
+    const errorSignal = signal3(null);
+    const isConnectedSignal = signal3(false);
+    const isRecordingSignal = signal3(false);
+    const partialSignal = signal3("");
+    const recordingErrorSignal = signal3(null);
+    const sessionIdSignal = signal3(controller.sessionId);
+    const statusSignal = signal3(controller.status);
+    const turnsSignal = signal3([]);
     const sync = () => {
       assistantAudioSignal.set([...controller.assistantAudio]);
       assistantTextsSignal.set([...controller.assistantTexts]);
@@ -1261,26 +1431,26 @@ class VoiceControllerService {
     const unsubscribe = controller.subscribe(sync);
     sync();
     return {
-      assistantAudio: computed2(() => assistantAudioSignal()),
-      assistantTexts: computed2(() => assistantTextsSignal()),
+      assistantAudio: computed3(() => assistantAudioSignal()),
+      assistantTexts: computed3(() => 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: computed3(() => errorSignal()),
+      isConnected: computed3(() => isConnectedSignal()),
+      isRecording: computed3(() => isRecordingSignal()),
+      partial: computed3(() => partialSignal()),
+      recordingError: computed3(() => recordingErrorSignal()),
       sendAudio: (audio) => controller.sendAudio(audio),
-      sessionId: computed2(() => sessionIdSignal()),
+      sessionId: computed3(() => sessionIdSignal()),
       startRecording: () => controller.startRecording(),
-      status: computed2(() => statusSignal()),
+      status: computed3(() => statusSignal()),
       stopRecording: () => controller.stopRecording(),
       toggleRecording: () => controller.toggleRecording(),
-      turns: computed2(() => turnsSignal())
+      turns: computed3(() => turnsSignal())
     };
   }
 }
@@ -1288,7 +1458,381 @@ VoiceControllerService = __decorateElement(_init, 0, "VoiceControllerService", _
 __runInitializers(_init, 1, VoiceControllerService);
 __decoratorMetadata(_init, VoiceControllerService);
 let _VoiceControllerService = VoiceControllerService;
+// src/angular/voice-provider-status.service.ts
+import { computed as computed4, Injectable as Injectable4, signal as signal4 } 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 = [
+  Injectable4({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderStatusService {
+  connect(path = "/api/provider-status", options = {}) {
+    const store = createVoiceProviderStatusStore(path, options);
+    const errorSignal = signal4(null);
+    const isLoadingSignal = signal4(false);
+    const providersSignal = signal4([]);
+    const updatedAtSignal = signal4(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: computed4(() => errorSignal()),
+      isLoading: computed4(() => isLoadingSignal()),
+      providers: computed4(() => providersSignal()),
+      refresh: store.refresh,
+      updatedAt: computed4(() => 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 Injectable5, signal as signal5 } 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 = [
+  Injectable5({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceRoutingStatusService {
+  connect(path = "/api/routing/latest", options = {}) {
+    const store = createVoiceRoutingStatusStore(path, options);
+    const decisionSignal = signal5(null);
+    const errorSignal = signal5(null);
+    const isLoadingSignal = signal5(false);
+    const updatedAtSignal = signal5(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-workflow-status.service.ts
+import { computed as computed5, Injectable as Injectable6, signal as signal6 } 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 = [
+  Injectable6({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceWorkflowStatusService {
+  connect(path = "/evals/scenarios/json", options = {}) {
+    const store = createVoiceWorkflowStatusStore(path, options);
+    const errorSignal = signal6(null);
+    const isLoadingSignal = signal6(false);
+    const reportSignal = signal6(undefined);
+    const updatedAtSignal = signal6(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: computed5(() => errorSignal()),
+      isLoading: computed5(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed5(() => reportSignal()),
+      updatedAt: computed5(() => updatedAtSignal())
+    };
+  }
+}
+VoiceWorkflowStatusService = __decorateElement(_init, 0, "VoiceWorkflowStatusService", _dec, VoiceWorkflowStatusService);
+__runInitializers(_init, 1, VoiceWorkflowStatusService);
+__decoratorMetadata(_init, VoiceWorkflowStatusService);
+let _VoiceWorkflowStatusService = VoiceWorkflowStatusService;
 export {
+  VoiceWorkflowStatusService,
   VoiceStreamService,
-  VoiceControllerService
+  VoiceRoutingStatusService,
+  VoiceProviderStatusService,
+  VoiceControllerService,
+  VoiceAppKitStatusService
 };