@absolutejs/voice 0.0.22-beta.216 → 0.0.22-beta.218

package/README.md

@@ -2741,6 +2741,51 @@ app.use(
 
 Readiness emits the stable `voice.readiness.ops_recovery` gate code when unresolved recovery issues remain.
 
+## Customer-Owned Observability Export
+
+Use observability exports when a buyer wants the hosted-dashboard evidence graph, but inside their own storage, warehouse, SIEM, incident flow, or release notes. The export manifest links traces, audits, operations records, delivery queues, provider SLOs, readiness reports, screenshots, and proof-pack artifacts without making AbsoluteJS Voice the dashboard.
+
+```ts
+import {
+	buildVoiceObservabilityExport,
+	createVoiceObservabilityExportRoutes
+} from '@absolutejs/voice';
+
+app.use(
+	createVoiceObservabilityExportRoutes({
+		artifacts: [
+			{
+				id: 'latest-proof-pack',
+				kind: 'proof-pack',
+				label: 'Latest proof pack',
+				path: '.voice-runtime/proof-pack/latest.md'
+			}
+		],
+		audit: runtimeStorage.audit,
+		auditDeliveries: runtimeStorage.auditDeliveries,
+		links: {
+			operationsRecord: (sessionId) => `/voice-operations/${sessionId}`
+		},
+		redact: true,
+		store: runtimeStorage.traces,
+		traceDeliveries: runtimeStorage.traceDeliveries
+	})
+);
+
+const exportReport = await buildVoiceObservabilityExport({
+	audit: runtimeStorage.audit,
+	auditDeliveries: runtimeStorage.auditDeliveries,
+	links: {
+		operationsRecord: (sessionId) => `/voice-operations/${sessionId}`
+	},
+	redact: true,
+	store: runtimeStorage.traces,
+	traceDeliveries: runtimeStorage.traceDeliveries
+});
+```
+
+The route helper exposes JSON at `/api/voice/observability-export`, Markdown at `/voice/observability-export.md`, and HTML at `/voice/observability-export`. Failed trace/audit deliveries fail the export report, pending deliveries warn, and every trace/audit envelope includes the linked operations-record URL when one is configured. This is the primitive to use when customers ask how voice evidence leaves the app without going through a hosted vendor dashboard.
+
 ## Production Voice Ops
 
 The recommended production pattern is:

package/dist/index.d.ts

@@ -53,6 +53,7 @@ export { createVoiceReadinessProfile, recommendVoiceReadinessProfile } from './r
 export { buildVoiceProviderContractMatrix, createVoiceProviderContractMatrixHTMLHandler, createVoiceProviderContractMatrixJSONHandler, createVoiceProviderContractMatrixPreset, createVoiceProviderContractMatrixRoutes, evaluateVoiceProviderStackGaps, renderVoiceProviderContractMatrixHTML, recommendVoiceProviderStack } from './providerStackRecommendations';
 export { buildVoiceOpsConsoleReport, createVoiceOpsConsoleRoutes, renderVoiceOpsConsoleHTML } from './opsConsoleRoutes';
 export { buildVoiceOperationsRecord, createVoiceOperationsRecordRoutes, renderVoiceOperationsRecordHTML, renderVoiceOperationsRecordIncidentMarkdown } from './operationsRecord';
+export { buildVoiceObservabilityExport, createVoiceObservabilityExportRoutes, renderVoiceObservabilityExportMarkdown } from './observabilityExport';
 export { buildVoiceOpsRecoveryReadinessCheck, buildVoiceOpsRecoveryReport, createVoiceOpsRecoveryRoutes, renderVoiceOpsRecoveryHTML, renderVoiceOpsRecoveryMarkdown } from './opsRecovery';
 export { buildVoiceIncidentBundle, createStoredVoiceIncidentBundleArtifact, createVoiceIncidentBundleRoutes, createVoiceMemoryIncidentBundleStore, pruneVoiceIncidentBundleArtifacts, saveVoiceIncidentBundleArtifact } from './incidentBundle';
 export { summarizeVoiceOpsStatus } from './opsStatus';
@@ -117,6 +118,7 @@ export type { VoiceProductionReadinessAction, VoiceProductionReadinessAuditOptio
 export type { VoiceReadinessProfileName, VoiceReadinessProfileOptions, VoiceReadinessProfileRecommendation, VoiceReadinessProfileRecommendationScore, VoiceReadinessProfileRoutesOptions } from './readinessProfiles';
 export type { VoiceProviderStackChoice, VoiceProviderStackCapabilities, VoiceProviderStackCapabilityGap, VoiceProviderStackCapabilityGapInput, VoiceProviderStackCapabilityGapReport, VoiceProviderContractCheck, VoiceProviderContractCheckStatus, VoiceProviderContractDefinition, VoiceProviderContractMatrixHandlerOptions, VoiceProviderContractMatrixHTMLHandlerOptions, VoiceProviderContractMatrixInput, VoiceProviderContractMatrixPresetOptions, VoiceProviderContractMatrixReport, VoiceProviderContractMatrixRoutesOptions, VoiceProviderContractMatrixRow, VoiceProviderStackInput, VoiceProviderStackKind, VoiceProviderStackRecommendation } from './providerStackRecommendations';
 export type { VoiceOperationsRecord, VoiceOperationsRecordAgentHandoff, VoiceOperationsRecordAuditSummary, VoiceOperationsRecordIntegrationEventSummary, VoiceOperationsRecordOptions, VoiceOperationsRecordOutcome, VoiceOperationsRecordProviderDecision, VoiceOperationsRecordReviewSummary, VoiceOperationsRecordRoutesOptions, VoiceOperationsRecordStatus, VoiceOperationsRecordTaskSummary, VoiceOperationsRecordTranscriptTurn, VoiceOperationsRecordTool } from './operationsRecord';
+export type { VoiceObservabilityExportArtifact, VoiceObservabilityExportArtifactKind, VoiceObservabilityExportDeliverySummary, VoiceObservabilityExportEnvelope, VoiceObservabilityExportIssue, VoiceObservabilityExportIssueCode, VoiceObservabilityExportOptions, VoiceObservabilityExportRedactionSummary, VoiceObservabilityExportReport, VoiceObservabilityExportRoutesOptions, VoiceObservabilityExportStatus } from './observabilityExport';
 export type { VoiceOpsRecoveryFailedSession, VoiceOpsRecoveryInterventionSummary, VoiceOpsRecoveryIssue, VoiceOpsRecoveryIssueCode, VoiceOpsRecoveryLinks, VoiceOpsRecoveryProviderSummary, VoiceOpsRecoveryReport, VoiceOpsRecoveryReportOptions, VoiceOpsRecoveryRoutesOptions, VoiceOpsRecoveryStatus } from './opsRecovery';
 export type { StoredVoiceIncidentBundleArtifact, VoiceIncidentBundle, VoiceIncidentBundleArtifactOptions, VoiceIncidentBundleFormat, VoiceIncidentBundleOptions, VoiceIncidentBundleRetentionOptions, VoiceIncidentBundleRetentionReport, VoiceIncidentBundleRoutesOptions, VoiceIncidentBundleStore, VoiceIncidentBundleStoreFilter, VoiceIncidentBundleSummary } from './incidentBundle';
 export type { VoiceQualityLink, VoiceQualityMetric, VoiceQualityReport, VoiceQualityRoutesOptions, VoiceQualityStatus, VoiceQualityThresholds } from './qualityRoutes';

package/dist/index.js

@@ -21397,6 +21397,7 @@ var listVoiceRoutingEvents = (events) => {
       operation: getString13(event.payload.operation),
       provider,
       routing: getString13(event.payload.routing),
+      scenarioId: event.scenarioId,
       selectedProvider: getString13(event.payload.selectedProvider),
       sessionId: event.sessionId,
       status: providerStatus,
@@ -22067,7 +22068,7 @@ var summarizeSessions = (events) => {
 var buildVoiceProviderSloReport = async (options = {}) => {
   const rawEvents = options.events ?? await options.store?.list() ?? [];
   const now = options.now ?? Date.now();
-  const events = normalizeEvents2(rawEvents).filter((event) => typeof options.maxAgeMs !== "number" || now - event.at <= options.maxAgeMs);
+  const events = normalizeEvents2(rawEvents).filter((event) => (typeof options.maxAgeMs !== "number" || now - event.at <= options.maxAgeMs) && (!options.sessionId || event.sessionId === options.sessionId) && (!options.scenarioId || event.scenarioId === options.scenarioId));
   const thresholds = mergeThresholds(options.thresholds);
   const observedKinds = new Set(events.map((event) => event.kind));
   const requiredKinds = new Set(options.requiredKinds ?? [...observedKinds]);
@@ -24900,8 +24901,266 @@ var createVoiceOperationsRecordRoutes = (options) => {
   }
   return routes;
 };
-// src/incidentBundle.ts
+// src/observabilityExport.ts
 import { Elysia as Elysia42 } from "elysia";
+var isDeliveryStore = (value) => !Array.isArray(value) && typeof value.list === "function";
+var getString18 = (value) => typeof value === "string" ? value : undefined;
+var getProviderKind = (payload) => getString18(payload.kind) ?? getString18(payload.providerKind);
+var toSeverityFromTrace = (event) => {
+  if (event.type === "session.error" || event.payload.status === "error" || event.payload.providerStatus === "error") {
+    return "fail";
+  }
+  if (event.payload.status === "fallback" || event.payload.providerStatus === "fallback") {
+    return "warn";
+  }
+  return "pass";
+};
+var toSeverityFromAudit = (event) => event.outcome === "error" ? "fail" : event.outcome === "skipped" ? "warn" : "pass";
+var createOperationArtifact = (record, href) => ({
+  generatedAt: record.checkedAt,
+  href,
+  id: `operations-record:${record.sessionId}`,
+  kind: "operations-record",
+  label: `Operations record ${record.sessionId}`,
+  sessionId: record.sessionId,
+  status: record.status === "failed" ? "fail" : record.status === "warning" ? "warn" : "pass"
+});
+var unique2 = (values) => [...new Set(values)].sort();
+var collectSessionIds = (input) => unique2([
+  ...input.sessionIds ?? [],
+  ...input.events.map((event) => event.sessionId),
+  ...input.auditEvents.map((event) => event.sessionId).filter((sessionId) => Boolean(sessionId)),
+  ...input.operationsRecords.map((record) => record.sessionId)
+]);
+var collectIssues = (input) => {
+  const issues = [];
+  const failedOperationsRecords = input.operationsRecords.filter((record) => record.status === "failed").length;
+  if (input.totalEvidence === 0) {
+    issues.push({
+      code: "voice.observability.no_evidence",
+      detail: "No traces, audits, operations records, or artifacts were included in the export manifest.",
+      label: "Observability evidence",
+      severity: "warn",
+      value: 0
+    });
+  }
+  if (failedOperationsRecords > 0) {
+    issues.push({
+      code: "voice.observability.operation_failed",
+      label: "Failed operations records",
+      severity: "fail",
+      value: failedOperationsRecords
+    });
+  }
+  if ((input.auditDeliveries?.failed ?? 0) > 0) {
+    issues.push({
+      code: "voice.observability.audit_delivery_failed",
+      label: "Failed audit exports",
+      severity: "fail",
+      value: input.auditDeliveries?.failed
+    });
+  }
+  if ((input.auditDeliveries?.pending ?? 0) > 0) {
+    issues.push({
+      code: "voice.observability.audit_delivery_pending",
+      label: "Pending audit exports",
+      severity: "warn",
+      value: input.auditDeliveries?.pending
+    });
+  }
+  if ((input.traceDeliveries?.failed ?? 0) > 0) {
+    issues.push({
+      code: "voice.observability.trace_delivery_failed",
+      label: "Failed trace exports",
+      severity: "fail",
+      value: input.traceDeliveries?.failed
+    });
+  }
+  if ((input.traceDeliveries?.pending ?? 0) > 0) {
+    issues.push({
+      code: "voice.observability.trace_delivery_pending",
+      label: "Pending trace exports",
+      severity: "warn",
+      value: input.traceDeliveries?.pending
+    });
+  }
+  return issues;
+};
+var buildTraceEnvelope = (event, operationsRecordHref) => ({
+  at: event.at,
+  eventId: event.id,
+  eventType: event.type,
+  kind: "trace",
+  operationsRecordHref,
+  provider: getString18(event.payload.provider),
+  providerKind: getProviderKind(event.payload),
+  scenarioId: event.scenarioId,
+  sessionId: event.sessionId,
+  severity: toSeverityFromTrace(event),
+  traceId: event.traceId
+});
+var buildAuditEnvelope = (event, operationsRecordHref) => ({
+  at: event.at,
+  eventId: event.id,
+  eventType: event.type,
+  kind: "audit",
+  operationsRecordHref,
+  provider: getString18(event.payload?.provider),
+  providerKind: getProviderKind(event.payload ?? {}),
+  sessionId: event.sessionId,
+  severity: toSeverityFromAudit(event),
+  traceId: event.traceId
+});
+var buildVoiceObservabilityExport = async (options = {}) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  const auditEvents = options.audit ? await options.audit.list() : [];
+  const baseOperationsRecords = options.operationsRecords ?? [];
+  const sessionIds = collectSessionIds({
+    auditEvents,
+    events,
+    operationsRecords: baseOperationsRecords,
+    sessionIds: options.sessionIds
+  });
+  const shouldBuildOperationsRecords = options.includeOperationsRecords !== false && options.store;
+  const builtOperationsRecords = shouldBuildOperationsRecords ? await Promise.all(sessionIds.map((sessionId) => buildVoiceOperationsRecord({
+    audit: options.audit,
+    redact: options.redact,
+    sessionId,
+    store: options.store
+  }))) : [];
+  const operationsRecords = [
+    ...baseOperationsRecords,
+    ...builtOperationsRecords.filter((record) => !baseOperationsRecords.some((existing) => existing.sessionId === record.sessionId))
+  ];
+  const traceDeliveries = options.traceDeliveries ? isDeliveryStore(options.traceDeliveries) ? await options.traceDeliveries.list() : options.traceDeliveries : undefined;
+  const auditDeliveries = options.auditDeliveries ? isDeliveryStore(options.auditDeliveries) ? await options.auditDeliveries.list() : options.auditDeliveries : undefined;
+  const traceDeliverySummary = traceDeliveries ? await summarizeVoiceTraceSinkDeliveries(traceDeliveries) : undefined;
+  const auditDeliverySummary = auditDeliveries ? await summarizeVoiceAuditSinkDeliveries(auditDeliveries) : undefined;
+  const operationArtifacts = operationsRecords.map((record) => createOperationArtifact(record, options.links?.operationsRecord?.(record.sessionId)));
+  const artifacts = [...operationArtifacts, ...options.artifacts ?? []];
+  const operationHrefBySessionId = new Map(operationsRecords.map((record) => [
+    record.sessionId,
+    options.links?.operationsRecord?.(record.sessionId)
+  ]));
+  const envelopes = [
+    ...events.map((event) => buildTraceEnvelope(event, operationHrefBySessionId.get(event.sessionId))),
+    ...auditEvents.map((event) => buildAuditEnvelope(event, event.sessionId ? operationHrefBySessionId.get(event.sessionId) : undefined))
+  ].sort((left, right) => left.at - right.at);
+  const issues = collectIssues({
+    auditDeliveries: auditDeliverySummary,
+    operationsRecords,
+    totalEvidence: events.length + auditEvents.length + operationsRecords.length + artifacts.length,
+    traceDeliveries: traceDeliverySummary
+  });
+  const status = issues.some((issue) => issue.severity === "fail") ? "fail" : issues.some((issue) => issue.severity === "warn") ? "warn" : "pass";
+  return {
+    artifacts,
+    checkedAt: Date.now(),
+    deliveries: {
+      audit: auditDeliverySummary,
+      trace: traceDeliverySummary
+    },
+    envelopes,
+    issues,
+    operationsRecords,
+    redaction: {
+      enabled: Boolean(options.redact),
+      mode: options.redact ? "redacted" : "none"
+    },
+    sessionIds,
+    status,
+    summary: {
+      auditEvents: auditEvents.length,
+      events: events.length + auditEvents.length,
+      failedOperationsRecords: operationsRecords.filter((record) => record.status === "failed").length,
+      trace: summarizeVoiceTrace(events),
+      traceEvents: events.length
+    }
+  };
+};
+var renderVoiceObservabilityExportMarkdown = (report, options = {}) => {
+  const title = options.title ?? "Voice Observability Export";
+  const issues = report.issues.map((issue) => `- ${issue.severity}: ${issue.label}${issue.value !== undefined ? ` (${issue.value})` : ""}${issue.detail ? ` - ${issue.detail}` : ""}`).join(`
+`) || "No observability export issues.";
+  const artifacts = report.artifacts.map((artifact) => `- ${artifact.label}: ${artifact.kind}${artifact.href ? ` (${artifact.href})` : ""}${artifact.status ? ` - ${artifact.status}` : ""}`).join(`
+`) || "No artifacts attached.";
+  return `# ${title}
+
+Generated: ${new Date(report.checkedAt).toISOString()}
+
+Overall: **${report.status}**
+
+Redaction: **${report.redaction.mode}**
+
+Sessions: ${report.sessionIds.length}
+
+Trace events: ${report.summary.traceEvents}
+
+Audit events: ${report.summary.auditEvents}
+
+Operations records: ${report.operationsRecords.length}
+
+Artifacts: ${report.artifacts.length}
+
+## Delivery Summary
+
+Trace deliveries: ${report.deliveries.trace ? `${report.deliveries.trace.delivered} delivered, ${report.deliveries.trace.pending} pending, ${report.deliveries.trace.failed} failed` : "not configured"}
+
+Audit deliveries: ${report.deliveries.audit ? `${report.deliveries.audit.delivered} delivered, ${report.deliveries.audit.pending} pending, ${report.deliveries.audit.failed} failed` : "not configured"}
+
+## Artifacts
+
+${artifacts}
+
+## Issues
+
+${issues}
+`;
+};
+var createVoiceObservabilityExportRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/observability-export";
+  const markdownPath = options.markdownPath ?? "/voice/observability-export.md";
+  const htmlPath = options.htmlPath ?? "/voice/observability-export";
+  const headers = {
+    "cache-control": "no-store",
+    ...options.headers ?? {}
+  };
+  const buildReport = () => buildVoiceObservabilityExport(options);
+  const app = new Elysia42({
+    name: options.name ?? "absolute-voice-observability-export"
+  });
+  app.get(path, async () => Response.json(await buildReport(), { headers }));
+  if (markdownPath !== false) {
+    app.get(markdownPath, async () => {
+      const report = await buildReport();
+      return new Response(renderVoiceObservabilityExportMarkdown(report, {
+        title: options.title
+      }), {
+        headers: {
+          ...headers,
+          "content-type": "text/markdown; charset=utf-8"
+        }
+      });
+    });
+  }
+  if (htmlPath !== false) {
+    app.get(htmlPath, async () => {
+      const report = await buildReport();
+      const markdown = options.render ? await options.render(report) : renderVoiceObservabilityExportMarkdown(report, {
+        title: options.title
+      });
+      return new Response(`<!doctype html><html><head><meta charset="utf-8" /><title>${options.title ?? "Voice Observability Export"}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:auto;max-width:920px;padding:32px;white-space:pre-wrap}</style></head><body>${markdown}</body></html>`, {
+        headers: {
+          ...headers,
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    });
+  }
+  return app;
+};
+// src/incidentBundle.ts
+import { Elysia as Elysia43 } from "elysia";
 var filterIncidentBundleArtifacts = (artifacts, filter = {}) => artifacts.filter((artifact) => {
   if (filter.sessionId && artifact.sessionId !== filter.sessionId) {
     return false;
@@ -25100,7 +25359,7 @@ var buildVoiceIncidentBundle = async (options) => {
 var createVoiceIncidentBundleRoutes = (options) => {
   const path = options.path ?? "/api/voice-incidents/:sessionId";
   const markdownPath = options.markdownPath === undefined ? "/voice-incidents/:sessionId/markdown" : options.markdownPath;
-  const routes = new Elysia42({
+  const routes = new Elysia43({
     name: options.name ?? "absolutejs-voice-incident-bundle"
   });
   const getSessionId = (params) => params.sessionId ?? "";
@@ -25301,7 +25560,7 @@ var summarizeVoiceOpsStatus = async (options) => {
   };
 };
 // src/opsStatusRoutes.ts
-import { Elysia as Elysia43 } from "elysia";
+import { Elysia as Elysia44 } from "elysia";
 var escapeHtml43 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var renderVoiceOpsStatusHTML = (report, options = {}) => {
   const title = options.title ?? "AbsoluteJS Voice Ops Status";
@@ -25313,7 +25572,7 @@ var renderVoiceOpsStatusHTML = (report, options = {}) => {
 };
 var createVoiceOpsStatusRoutes = (options) => {
   const path = options.path ?? "/api/voice/ops-status";
-  const routes = new Elysia43({
+  const routes = new Elysia44({
     name: options.name ?? "absolutejs-voice-ops-status"
   });
   routes.get(path, async () => summarizeVoiceOpsStatus(options));
@@ -25746,9 +26005,9 @@ var createVoiceTTSProviderRouter = (options) => {
   };
 };
 // src/traceDeliveryRoutes.ts
-import { Elysia as Elysia44 } from "elysia";
+import { Elysia as Elysia45 } from "elysia";
 var escapeHtml44 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
-var getString18 = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var getString19 = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
 var getNumber11 = (value) => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -25760,13 +26019,13 @@ var getNumber11 = (value) => {
   return;
 };
 var parseStatus2 = (value) => {
-  const text = getString18(value);
+  const text = getString19(value);
   return text === "pending" || text === "delivered" || text === "failed" || text === "skipped" || text === "all" ? text : undefined;
 };
 var resolveVoiceTraceDeliveryFilter = (query = {}, base = {}) => ({
   ...base,
   limit: getNumber11(query.limit) ?? base.limit,
-  q: getString18(query.q) ?? base.q,
+  q: getString19(query.q) ?? base.q,
   status: parseStatus2(query.status) ?? base.status
 });
 var deliverySearchText2 = (delivery) => [
@@ -25855,7 +26114,7 @@ var createVoiceTraceDeliveryRoutes = (options) => {
   const path = options.path ?? "/api/voice-trace-deliveries";
   const htmlPath = options.htmlPath === undefined ? "/traces/deliveries" : options.htmlPath;
   const workerPath = options.workerPath === undefined ? `${path}/drain` : options.workerPath;
-  const routes = new Elysia44({
+  const routes = new Elysia45({
     name: options.name ?? "absolutejs-voice-trace-deliveries"
   }).get(path, createVoiceTraceDeliveryJSONHandler(options));
   if (htmlPath !== false) {
@@ -26479,7 +26738,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia45 } from "elysia";
+import { Elysia as Elysia46 } from "elysia";
 var toHex6 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
   const encoder = new TextEncoder;
@@ -26609,7 +26868,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia45().post(path, async ({ body, request, set }) => {
+  return new Elysia46().post(path, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -27560,6 +27819,7 @@ export {
   renderVoiceOpsActionHistoryHTML,
   renderVoiceOperationsRecordIncidentMarkdown,
   renderVoiceOperationsRecordHTML,
+  renderVoiceObservabilityExportMarkdown,
   renderVoiceLiveLatencyHTML,
   renderVoiceLatencySLOMarkdown,
   renderVoiceHandoffHealthHTML,
@@ -27758,6 +28018,7 @@ export {
   createVoiceOpsConsoleRoutes,
   createVoiceOpsActionAuditRoutes,
   createVoiceOperationsRecordRoutes,
+  createVoiceObservabilityExportRoutes,
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
@@ -27894,6 +28155,7 @@ export {
   buildVoiceOpsConsoleReport,
   buildVoiceOpsActionHistoryReport,
   buildVoiceOperationsRecord,
+  buildVoiceObservabilityExport,
   buildVoiceLiveOpsControlState,
   buildVoiceLatencySLOGate,
   buildVoiceIncidentBundle,

package/dist/observabilityExport.d.ts

@@ -0,0 +1,123 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore } from './auditSinks';
+import type { VoiceAuditEventStore, VoiceAuditEventType } from './audit';
+import { type VoiceOperationsRecord } from './operationsRecord';
+import { type VoiceTraceSinkDeliveryQueueSummary } from './queue';
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore, type VoiceTraceEventType, type VoiceTraceRedactionConfig, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceSummary } from './trace';
+export type VoiceObservabilityExportStatus = 'fail' | 'pass' | 'warn';
+export type VoiceObservabilityExportArtifactKind = 'incident' | 'markdown' | 'operations-record' | 'proof-pack' | 'readiness' | 'screenshot' | 'slo' | 'trace' | 'audit' | 'custom';
+export type VoiceObservabilityExportArtifact = {
+    bytes?: number;
+    contentType?: string;
+    generatedAt?: number | string;
+    href?: string;
+    id: string;
+    kind: VoiceObservabilityExportArtifactKind;
+    label: string;
+    path?: string;
+    sessionId?: string;
+    status?: VoiceObservabilityExportStatus;
+};
+export type VoiceObservabilityExportEnvelope = {
+    at: number;
+    eventId: string;
+    eventType: VoiceTraceEventType | VoiceAuditEventType;
+    kind: 'audit' | 'trace';
+    operationsRecordHref?: string;
+    provider?: string;
+    providerKind?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    severity: VoiceObservabilityExportStatus;
+    traceId?: string;
+};
+export type VoiceObservabilityExportIssueCode = 'voice.observability.no_evidence' | 'voice.observability.operation_failed' | 'voice.observability.audit_delivery_failed' | 'voice.observability.audit_delivery_pending' | 'voice.observability.trace_delivery_failed' | 'voice.observability.trace_delivery_pending';
+export type VoiceObservabilityExportIssue = {
+    code: VoiceObservabilityExportIssueCode;
+    detail?: string;
+    label: string;
+    severity: Exclude<VoiceObservabilityExportStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceObservabilityExportDeliverySummary = {
+    audit?: VoiceAuditSinkDeliveryQueueSummary;
+    trace?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceObservabilityExportRedactionSummary = {
+    enabled: boolean;
+    mode: 'none' | 'redacted';
+};
+export type VoiceObservabilityExportReport = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    checkedAt: number;
+    deliveries: VoiceObservabilityExportDeliverySummary;
+    envelopes: VoiceObservabilityExportEnvelope[];
+    issues: VoiceObservabilityExportIssue[];
+    operationsRecords: VoiceOperationsRecord[];
+    redaction: VoiceObservabilityExportRedactionSummary;
+    sessionIds: string[];
+    status: VoiceObservabilityExportStatus;
+    summary: {
+        auditEvents: number;
+        events: number;
+        failedOperationsRecords: number;
+        trace: VoiceTraceSummary;
+        traceEvents: number;
+    };
+};
+export type VoiceObservabilityExportOptions = {
+    artifacts?: VoiceObservabilityExportArtifact[];
+    audit?: VoiceAuditEventStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryRecord[] | VoiceAuditSinkDeliveryStore;
+    events?: StoredVoiceTraceEvent[];
+    includeOperationsRecords?: boolean;
+    links?: {
+        operationsRecord?: (sessionId: string) => string;
+    };
+    operationsRecords?: VoiceOperationsRecord[];
+    redact?: VoiceTraceRedactionConfig;
+    sessionIds?: string[];
+    store?: VoiceTraceEventStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryRecord[] | VoiceTraceSinkDeliveryStore;
+};
+export type VoiceObservabilityExportRoutesOptions = VoiceObservabilityExportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceObservabilityExportReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceObservabilityExport: (options?: VoiceObservabilityExportOptions) => Promise<VoiceObservabilityExportReport>;
+export declare const renderVoiceObservabilityExportMarkdown: (report: VoiceObservabilityExportReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceObservabilityExportRoutes: (options?: VoiceObservabilityExportRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/providerSlo.d.ts

@@ -65,6 +65,8 @@ export type VoiceProviderSloReportOptions = {
     maxAgeMs?: number;
     now?: number;
     requiredKinds?: readonly VoiceRoutingEventKind[];
+    scenarioId?: string;
+    sessionId?: string;
     store?: VoiceTraceEventStore;
     thresholds?: VoiceProviderSloThresholdConfig;
 };

package/dist/resilienceRoutes.d.ts

@@ -14,6 +14,7 @@ export type VoiceRoutingEvent = {
     operation?: string;
     provider?: string;
     routing?: string;
+    scenarioId?: string;
     selectedProvider?: string;
     sessionId: string;
     status?: string;

package/package.json

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