@absolutejs/voice 0.0.22-beta.363 → 0.0.22-beta.365

package/dist/index.js

@@ -32423,10 +32423,12 @@ var buildVoiceProductionReadinessReport = async (options, input = {}) => {
   const request = input.request ?? new Request("http://localhost/");
   const query = input.query ?? {};
   const events = await options.store.list();
-  const routingEvents = listVoiceRoutingEvents(events);
+  const minTraceAt = typeof options.traceMaxAgeMs === "number" && Number.isFinite(options.traceMaxAgeMs) && options.traceMaxAgeMs > 0 ? Date.now() - options.traceMaxAgeMs : undefined;
+  const readinessEvents = minTraceAt === undefined ? events : events.filter((event) => event.at >= minTraceAt);
+  const routingEvents = listVoiceRoutingEvents(readinessEvents);
   const routingSessions = summarizeVoiceRoutingSessions(routingEvents);
-  const liveLatency = summarizeLiveLatency(events, options);
-  const providerRecovery = summarizeVoiceProviderFallbackRecovery(events);
+  const liveLatency = summarizeLiveLatency(readinessEvents, options);
+  const providerRecovery = summarizeVoiceProviderFallbackRecovery(readinessEvents);
   const [
     quality,
     providers,
@@ -32462,23 +32464,23 @@ var buildVoiceProductionReadinessReport = async (options, input = {}) => {
     proofSources,
     additionalChecks
   ] = await Promise.all([
-    evaluateVoiceQuality({ events }),
+    evaluateVoiceQuality({ events: readinessEvents }),
     Promise.all([
       summarizeVoiceProviderHealth({
-        events,
+        events: readinessEvents,
         providers: options.llmProviders ?? []
       }),
       summarizeVoiceProviderHealth({
-        events: events.filter((event) => event.payload.kind === "stt"),
+        events: readinessEvents.filter((event) => event.payload.kind === "stt"),
         providers: options.sttProviders ?? []
       }),
       summarizeVoiceProviderHealth({
-        events: events.filter((event) => event.payload.kind === "tts"),
+        events: readinessEvents.filter((event) => event.payload.kind === "tts"),
         providers: options.ttsProviders ?? []
       })
     ]).then((groups) => groups.flat()),
-    summarizeVoiceSessions({ events, status: "all" }),
-    summarizeVoiceHandoffHealth({ events }),
+    summarizeVoiceSessions({ events: readinessEvents, status: "all" }),
+    summarizeVoiceHandoffHealth({ events: readinessEvents }),
     summarizeAuditEvidence(options),
     summarizeAuditDeliveries(options),
     summarizeOpsActionHistory(options),
@@ -32515,7 +32517,7 @@ var buildVoiceProductionReadinessReport = async (options, input = {}) => {
   const failedSessionItems = sessions.filter((session) => session.status === "failed");
   const operationsRecords = buildOperationsRecordLinks({
     base: options.links?.operationsRecords ?? "/voice-operations",
-    events,
+    events: readinessEvents,
     failedSessionIds: failedSessionItems.map((session) => session.sessionId),
     liveLatencyFailAfterMs: options.liveLatencyFailAfterMs ?? 3200,
     liveLatencyMaxAgeMs: options.liveLatencyMaxAgeMs,
@@ -33563,6 +33565,7 @@ var createVoiceProductionReadinessRoutes = (options) => {
   const routes = new Elysia54({
     name: options.name ?? "absolutejs-voice-production-readiness"
   });
+  let cachedReport;
   const resolveOptions = async (input) => {
     if (!options.resolveOptions) {
       return options;
@@ -33572,14 +33575,41 @@ var createVoiceProductionReadinessRoutes = (options) => {
       ...await options.resolveOptions(input)
     };
   };
-  routes.get(path, async ({ query, request }) => buildVoiceProductionReadinessReport(await resolveOptions({ query, request }), { query, request }));
+  const reportCacheKey = (query, request) => {
+    const url = new URL(request.url);
+    const queryKey = Object.entries(query).map(([key, value]) => [key, String(value)]).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("&");
+    return `${url.pathname}?${queryKey}`;
+  };
+  const getReport = async (query, request) => {
+    const cacheMs = typeof options.cacheMs === "number" && Number.isFinite(options.cacheMs) && options.cacheMs > 0 ? options.cacheMs : 0;
+    const key = reportCacheKey(query, request);
+    if (cacheMs > 0 && cachedReport && cachedReport.key === key && Date.now() - cachedReport.loadedAt <= cacheMs) {
+      return cachedReport.value;
+    }
+    const value = (async () => {
+      const resolvedOptions = await resolveOptions({ query, request });
+      return {
+        report: await buildVoiceProductionReadinessReport(resolvedOptions, {
+          query,
+          request
+        }),
+        resolvedOptions
+      };
+    })();
+    if (cacheMs > 0) {
+      cachedReport = {
+        key,
+        loadedAt: Date.now(),
+        value
+      };
+    }
+    return value;
+  };
+  routes.get(path, async ({ query, request }) => (await getReport(query, request)).report);
   if (gatePath !== false) {
     routes.get(gatePath, async ({ query, request }) => {
-      const resolvedOptions = await resolveOptions({ query, request });
-      const gate = await buildVoiceProductionReadinessGate(resolvedOptions, {
-        query,
-        request
-      });
+      const { report, resolvedOptions } = await getReport(query, request);
+      const gate = summarizeVoiceProductionReadinessGate(report, resolvedOptions.gate || undefined);
       return new Response(JSON.stringify(gate), {
         headers: {
           "Content-Type": "application/json; charset=utf-8",
@@ -33591,11 +33621,7 @@ var createVoiceProductionReadinessRoutes = (options) => {
   }
   if (htmlPath !== false) {
     routes.get(htmlPath, async ({ query, request }) => {
-      const resolvedOptions = await resolveOptions({ query, request });
-      const report = await buildVoiceProductionReadinessReport(resolvedOptions, {
-        query,
-        request
-      });
+      const { report, resolvedOptions } = await getReport(query, request);
       const body = await (resolvedOptions.render ?? renderVoiceProductionReadinessHTML)(report);
       return new Response(body, {
         headers: {

package/dist/productionReadiness.d.ts

@@ -484,6 +484,7 @@ export type VoiceProductionReadinessRoutesOptions = {
         query: Record<string, unknown>;
         request: Request;
     }) => Promise<VoiceCampaignReadinessProofReport> | VoiceCampaignReadinessProofReport);
+    cacheMs?: number;
     deliveryRuntime?: false | VoiceDeliveryRuntime | VoiceDeliveryRuntimeSummary | ((input: {
         query: Record<string, unknown>;
         request: Request;
@@ -581,6 +582,7 @@ export type VoiceProductionReadinessRoutesOptions = {
     title?: string;
     traceDeliveries?: false | VoiceProductionReadinessTraceDeliveryOptions;
     ttsProviders?: readonly string[];
+    traceMaxAgeMs?: number;
     liveLatencyWarnAfterMs?: number;
     liveLatencyFailAfterMs?: number;
     liveLatencyMaxAgeMs?: number;

package/package.json

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