@absolutejs/voice 0.0.22-beta.242 → 0.0.22-beta.244

package/dist/client/proofTrends.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProofTrendReport } from '../proofTrends';
+export type VoiceProofTrendsClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProofTrendsSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceProofTrendReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProofTrends: (path?: string, options?: Pick<VoiceProofTrendsClientOptions, "fetch">) => Promise<VoiceProofTrendReport>;
+export declare const createVoiceProofTrendsStore: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProofTrendsSnapshot;
+    getSnapshot: () => VoiceProofTrendsSnapshot;
+    refresh: () => Promise<VoiceProofTrendReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/proofTrendsWidget.d.ts

@@ -0,0 +1,37 @@
+import { type VoiceProofTrendReport } from '../proofTrends';
+import { type VoiceProofTrendsClientOptions, type VoiceProofTrendsSnapshot } from './proofTrends';
+export type VoiceProofTrendsMetricView = {
+    label: string;
+    value: string;
+};
+export type VoiceProofTrendsViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    metrics: VoiceProofTrendsMetricView[];
+    report?: VoiceProofTrendReport;
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProofTrendsWidgetOptions = VoiceProofTrendsClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    title?: string;
+};
+export declare const createVoiceProofTrendsViewModel: (snapshot: VoiceProofTrendsSnapshot, options?: VoiceProofTrendsWidgetOptions) => VoiceProofTrendsViewModel;
+export declare const renderVoiceProofTrendsHTML: (snapshot: VoiceProofTrendsSnapshot, options?: VoiceProofTrendsWidgetOptions) => string;
+export declare const getVoiceProofTrendsCSS: () => string;
+export declare const mountVoiceProofTrends: (element: Element, path?: string, options?: VoiceProofTrendsWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceProofTrendReport | undefined>;
+};
+export declare const defineVoiceProofTrendsElement: (tagName?: string) => void;

package/dist/index.d.ts

@@ -83,6 +83,7 @@ export { createVoiceCallReviewFromSession, recordVoiceRuntimeOps } from './runti
 export { createVoiceOpsRuntime } from './opsRuntime';
 export { resolveVoiceOpsPreset } from './opsPresets';
 export { resolveVoiceOutcomeRecipe } from './outcomeRecipes';
+export { buildVoicePostCallAnalysisReport, createVoicePostCallAnalysisRoutes, renderVoicePostCallAnalysisMarkdown } from './postCallAnalysis';
 export { createId, createVoiceSessionRecord } from './store';
 export { createVoiceSTTRoutingCorrectionHandler, resolveVoiceSTTRoutingStrategy } from './routing';
 export { applyRiskTieredPhraseHintCorrections, applyPhraseHintCorrections, createDomainLexicon, createDomainPhraseHints, createPhraseHintCorrectionHandler, createRiskyTurnCorrectionHandler } from './correction';
@@ -135,6 +136,7 @@ export type { VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContr
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';
 export type { VoiceOutcomeRecipe, VoiceOutcomeRecipeName, VoiceOutcomeRecipeOptions } from './outcomeRecipes';
+export type { VoicePostCallAnalysisFieldRequirement, VoicePostCallAnalysisFieldResult, VoicePostCallAnalysisIssue, VoicePostCallAnalysisIssueCode, VoicePostCallAnalysisOptions, VoicePostCallAnalysisReport, VoicePostCallAnalysisRoutesOptions, VoicePostCallAnalysisStatus } from './postCallAnalysis';
 export type { VoiceCRMActivitySinkOptions, VoiceHubSpotTaskSinkOptions, VoiceHubSpotTaskUpdateSinkOptions, VoiceHelpdeskTicketSinkOptions, VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink, VoiceIntegrationSinkDeliveryResult, VoiceLinearIssueSinkOptions, VoiceLinearIssueUpdateSinkOptions, VoiceZendeskTicketSinkOptions, VoiceZendeskTicketUpdateSinkOptions } from './opsSinks';
 export type { VoiceOpsWebhookEnvelope, VoiceOpsWebhookEntity, VoiceOpsWebhookLinkResolver, VoiceOpsWebhookReceiverRoutesOptions, VoiceOpsWebhookSinkOptions, VoiceOpsWebhookVerificationResult } from './opsWebhook';
 export type { VoiceHandoffDelivery, VoiceHandoffDeliveryRecord, VoiceHandoffDeliveryRecordInput, VoiceHandoffFanoutResult, VoiceQueuedHandoffDeliveryOptions, VoiceTwilioRedirectHandoffAdapterOptions, VoiceWebhookHandoffAdapterOptions } from './handoff';

package/dist/index.js

@@ -28727,6 +28727,210 @@ var resolveVoiceOpsPreset = (name, overrides = {}) => {
     taskPolicies: mergePolicies(preset.taskPolicies, overrides.taskPolicies)
   };
 };
+// src/postCallAnalysis.ts
+import { Elysia as Elysia49 } from "elysia";
+var isStore = (value) => Boolean(value) && typeof value === "object" && value !== null && ("list" in value);
+var asArray = async (value) => Array.isArray(value) ? value : isStore(value) ? await value.list() : [];
+var getPathValue3 = (source, path) => {
+  const parts = path.split(".").filter(Boolean);
+  let current = source;
+  for (const part of parts) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+};
+var hasValue2 = (value) => {
+  if (value === undefined || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  return true;
+};
+var matchesReview = (reviewId, id) => Boolean(reviewId && id && (id === reviewId || id.startsWith(`${reviewId}:`)));
+var matchesSession = (sessionId, event) => {
+  const payloadSessionId = event.payload.sessionId;
+  return Boolean(sessionId && (event.id === sessionId || event.id.startsWith(`${sessionId}:`) || payloadSessionId === sessionId));
+};
+var matchesIntegrationEvent = (input) => {
+  const payloadReviewId = input.event.payload.reviewId;
+  return matchesReview(input.reviewId, input.event.id) || payloadReviewId === input.reviewId || matchesSession(input.sessionId, input.event);
+};
+var normalizeOperationRecordHref = (basePath, sessionId) => {
+  if (!basePath || !sessionId) {
+    return;
+  }
+  return basePath.includes(":sessionId") ? basePath.replace(":sessionId", encodeURIComponent(sessionId)) : `${basePath.replace(/\/$/, "")}/${encodeURIComponent(sessionId)}`;
+};
+var isPostCallAnalysisReport = (value) => ("status" in value) && ("summary" in value) && Array.isArray(value.issues);
+var buildVoicePostCallAnalysisReport = async (options = {}) => {
+  const reviews = await asArray(options.reviews);
+  const review = options.review ?? reviews.find((candidate) => options.reviewId ? candidate.id === options.reviewId : options.sessionId ? candidate.id.startsWith(`${options.sessionId}:`) : false);
+  const reviewId = options.reviewId ?? review?.id;
+  const sessionId = options.sessionId ?? (reviewId?.endsWith(":review") ? reviewId.slice(0, -":review".length) : undefined);
+  const allTasks = await asArray(options.tasks);
+  const tasks = allTasks.filter((task) => reviewId ? task.reviewId === reviewId || task.intakeId === reviewId || matchesReview(reviewId, task.id) : false);
+  const allIntegrationEvents = await asArray(options.integrationEvents);
+  const integrationEvents = allIntegrationEvents.filter((event) => matchesIntegrationEvent({ event, reviewId, sessionId }));
+  const fieldSource = {
+    extractedFields: options.extractedFields ?? {},
+    review
+  };
+  const fields = (options.fields ?? []).map((field) => {
+    const value = getPathValue3(fieldSource.extractedFields, field.path) ?? getPathValue3(fieldSource, field.path);
+    const required = field.required !== false;
+    return {
+      label: field.label ?? field.path,
+      ok: !required || hasValue2(value),
+      path: field.path,
+      required,
+      value
+    };
+  });
+  const requiredTaskKinds = options.requiredTaskKinds ?? [];
+  const missingTaskKinds = requiredTaskKinds.filter((kind) => !tasks.some((task) => task.kind === kind));
+  const deliveredIntegrationEvents = integrationEvents.filter((event) => event.deliveryStatus === "delivered").length;
+  const failedIntegrationEvents = integrationEvents.filter((event) => event.deliveryStatus === "failed").length;
+  const issues = [];
+  if (!review) {
+    issues.push({
+      code: "voice.post_call_analysis.review_missing",
+      label: "Review missing",
+      severity: "fail"
+    });
+  } else if (review.summary.pass === false) {
+    issues.push({
+      code: "voice.post_call_analysis.review_failed",
+      detail: review.errors.join("; ") || review.summary.outcome,
+      label: "Review failed",
+      severity: "fail"
+    });
+  }
+  for (const field of fields) {
+    if (field.required && !field.ok) {
+      issues.push({
+        code: "voice.post_call_analysis.required_field_missing",
+        detail: field.path,
+        label: `Missing ${field.label}`,
+        severity: "fail"
+      });
+    }
+  }
+  for (const kind of missingTaskKinds) {
+    issues.push({
+      code: "voice.post_call_analysis.required_task_missing",
+      detail: kind,
+      label: `Missing ${kind} task`,
+      severity: "fail"
+    });
+  }
+  if (options.requireDeliveredIntegrationEvent && deliveredIntegrationEvents === 0) {
+    issues.push({
+      code: "voice.post_call_analysis.integration_missing",
+      label: "Delivered integration event missing",
+      severity: "fail"
+    });
+  }
+  if (failedIntegrationEvents > 0) {
+    issues.push({
+      code: "voice.post_call_analysis.integration_failed",
+      detail: `${failedIntegrationEvents} failed integration event(s)`,
+      label: "Integration delivery failed",
+      severity: "warn"
+    });
+  }
+  const status = issues.some((issue) => issue.severity === "fail") ? "fail" : issues.length > 0 ? "warn" : "pass";
+  return {
+    checkedAt: options.at ?? Date.now(),
+    fields,
+    integrationEvents,
+    issues,
+    operationRecordHref: normalizeOperationRecordHref(options.operationRecordBasePath, sessionId),
+    review,
+    reviewId,
+    sessionId,
+    status,
+    summary: {
+      deliveredIntegrationEvents,
+      failedIntegrationEvents,
+      fields: fields.length,
+      missingRequiredFields: fields.filter((field) => field.required && !field.ok).length,
+      missingRequiredTasks: missingTaskKinds.length,
+      requiredFields: fields.filter((field) => field.required).length,
+      requiredTaskKinds: requiredTaskKinds.length,
+      tasks: tasks.length
+    },
+    tasks
+  };
+};
+var renderVoicePostCallAnalysisMarkdown = (report) => {
+  const lines = [
+    "# Voice Post-Call Analysis",
+    "",
+    `Status: ${report.status}`,
+    `Checked: ${new Date(report.checkedAt).toISOString()}`,
+    report.reviewId ? `Review: ${report.reviewId}` : undefined,
+    report.sessionId ? `Session: ${report.sessionId}` : undefined,
+    report.operationRecordHref ? `Operations record: ${report.operationRecordHref}` : undefined,
+    "",
+    "## Summary",
+    `- Fields: ${report.summary.fields}`,
+    `- Missing required fields: ${report.summary.missingRequiredFields}`,
+    `- Tasks: ${report.summary.tasks}`,
+    `- Missing required tasks: ${report.summary.missingRequiredTasks}`,
+    `- Delivered integration events: ${report.summary.deliveredIntegrationEvents}`,
+    `- Failed integration events: ${report.summary.failedIntegrationEvents}`,
+    "",
+    "## Issues",
+    ...report.issues.length ? report.issues.map((issue) => `- ${issue.severity}: ${issue.code} - ${issue.label}${issue.detail ? ` (${issue.detail})` : ""}`) : ["- none"]
+  ].filter((line) => line !== undefined);
+  return `${lines.join(`
+`)}
+`;
+};
+var resolvePostCallAnalysisReport = async (options, input) => {
+  const source = options.source === undefined ? options : typeof options.source === "function" ? await options.source(input) : options.source;
+  const merged = {
+    ...options,
+    ...source,
+    reviewId: input.reviewId ?? source.reviewId ?? options.reviewId,
+    sessionId: input.sessionId ?? source.sessionId ?? options.sessionId
+  };
+  return isPostCallAnalysisReport(merged) ? merged : buildVoicePostCallAnalysisReport(merged);
+};
+var createVoicePostCallAnalysisRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/post-call-analysis";
+  const routes = new Elysia49({
+    name: options.name ?? "absolutejs-voice-post-call-analysis"
+  });
+  routes.get(path, async ({ query }) => {
+    const report = await resolvePostCallAnalysisReport(options, {
+      reviewId: typeof query.reviewId === "string" ? query.reviewId : undefined,
+      sessionId: typeof query.sessionId === "string" ? query.sessionId : undefined
+    });
+    return Response.json(report, { headers: options.headers });
+  });
+  routes.get(`${path}.md`, async ({ query }) => {
+    const report = await resolvePostCallAnalysisReport(options, {
+      reviewId: typeof query.reviewId === "string" ? query.reviewId : undefined,
+      sessionId: typeof query.sessionId === "string" ? query.sessionId : undefined
+    });
+    return new Response(renderVoicePostCallAnalysisMarkdown(report), {
+      headers: {
+        "content-type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
 // src/correction.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var buildAliasMatcher = (alias) => new RegExp(`(?<![\\p{L}\\p{N}'])${escapeRegExp(alias)}(?![\\p{L}\\p{N}'])`, "giu");
@@ -29219,6 +29423,7 @@ export {
   renderVoiceProviderContractMatrixHTML,
   renderVoiceProviderCapabilityHTML,
   renderVoiceProductionReadinessHTML,
+  renderVoicePostCallAnalysisMarkdown,
   renderVoicePhoneAgentProductionSmokeHTML,
   renderVoiceOutcomeContractHTML,
   renderVoiceOpsStatusHTML,
@@ -29414,6 +29619,7 @@ export {
   createVoicePostgresCampaignStore,
   createVoicePostgresAuditSinkDeliveryStore,
   createVoicePostgresAuditEventStore,
+  createVoicePostCallAnalysisRoutes,
   createVoicePlivoCampaignDialer,
   createVoicePlatformCoverageRoutes,
   createVoicePhoneAgentProductionSmokeRoutes,
@@ -29570,6 +29776,7 @@ export {
   buildVoiceProofTrendReport,
   buildVoiceProductionReadinessReport,
   buildVoiceProductionReadinessGate,
+  buildVoicePostCallAnalysisReport,
   buildVoicePlatformCoverageSummary,
   buildVoiceOpsTaskFromSLABreach,
   buildVoiceOpsTaskFromReview,

package/dist/postCallAnalysis.d.ts

@@ -0,0 +1,98 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskKind, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+export type VoicePostCallAnalysisStatus = 'fail' | 'pass' | 'warn';
+export type VoicePostCallAnalysisFieldRequirement = {
+    label?: string;
+    path: string;
+    required?: boolean;
+};
+export type VoicePostCallAnalysisFieldResult = {
+    label: string;
+    ok: boolean;
+    path: string;
+    required: boolean;
+    value?: unknown;
+};
+export type VoicePostCallAnalysisIssueCode = 'voice.post_call_analysis.integration_failed' | 'voice.post_call_analysis.integration_missing' | 'voice.post_call_analysis.required_field_missing' | 'voice.post_call_analysis.required_task_missing' | 'voice.post_call_analysis.review_failed' | 'voice.post_call_analysis.review_missing';
+export type VoicePostCallAnalysisIssue = {
+    code: VoicePostCallAnalysisIssueCode;
+    detail?: string;
+    label: string;
+    severity: Exclude<VoicePostCallAnalysisStatus, 'pass'>;
+};
+export type VoicePostCallAnalysisReport = {
+    checkedAt: number;
+    fields: VoicePostCallAnalysisFieldResult[];
+    integrationEvents: StoredVoiceIntegrationEvent[];
+    issues: VoicePostCallAnalysisIssue[];
+    operationRecordHref?: string;
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    sessionId?: string;
+    status: VoicePostCallAnalysisStatus;
+    summary: {
+        deliveredIntegrationEvents: number;
+        failedIntegrationEvents: number;
+        fields: number;
+        missingRequiredFields: number;
+        missingRequiredTasks: number;
+        requiredFields: number;
+        requiredTaskKinds: number;
+        tasks: number;
+    };
+    tasks: StoredVoiceOpsTask[];
+};
+export type VoicePostCallAnalysisOptions = {
+    at?: number;
+    extractedFields?: Record<string, unknown>;
+    fields?: VoicePostCallAnalysisFieldRequirement[];
+    integrationEvents?: StoredVoiceIntegrationEvent[] | VoiceIntegrationEventStore;
+    operationRecordBasePath?: string;
+    requireDeliveredIntegrationEvent?: boolean;
+    requiredTaskKinds?: VoiceOpsTaskKind[];
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    reviews?: StoredVoiceCallReviewArtifact[] | VoiceCallReviewStore;
+    sessionId?: string;
+    tasks?: StoredVoiceOpsTask[] | VoiceOpsTaskStore;
+};
+export type VoicePostCallAnalysisRoutesOptions = VoicePostCallAnalysisOptions & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source?: ((input: {
+        reviewId?: string;
+        sessionId?: string;
+    }) => Promise<VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport> | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport) | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport;
+};
+export declare const buildVoicePostCallAnalysisReport: (options?: VoicePostCallAnalysisOptions) => Promise<VoicePostCallAnalysisReport>;
+export declare const renderVoicePostCallAnalysisMarkdown: (report: VoicePostCallAnalysisReport) => string;
+export declare const createVoicePostCallAnalysisRoutes: (options?: VoicePostCallAnalysisRoutesOptions) => 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/react/VoiceProofTrends.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProofTrendsWidgetOptions } from '../client/proofTrendsWidget';
+export type VoiceProofTrendsProps = VoiceProofTrendsWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProofTrends: ({ className, path, ...options }: VoiceProofTrendsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/index.d.ts

@@ -2,6 +2,7 @@ export { VoiceOpsStatus } from './VoiceOpsStatus';
 export { VoiceOpsActionCenter } from './VoiceOpsActionCenter';
 export { VoiceDeliveryRuntime } from './VoiceDeliveryRuntime';
 export { VoicePlatformCoverage } from './VoicePlatformCoverage';
+export { VoiceProofTrends } from './VoiceProofTrends';
 export { VoiceProviderSimulationControls } from './VoiceProviderSimulationControls';
 export { VoiceProviderCapabilities } from './VoiceProviderCapabilities';
 export { VoiceProviderContracts } from './VoiceProviderContracts';
@@ -13,6 +14,7 @@ export { VoiceTurnLatency } from './VoiceTurnLatency';
 export { VoiceTurnQuality } from './VoiceTurnQuality';
 export { useVoiceOpsStatus } from './useVoiceOpsStatus';
 export { useVoicePlatformCoverage } from './useVoicePlatformCoverage';
+export { useVoiceProofTrends } from './useVoiceProofTrends';
 export { useVoiceOpsActionCenter } from './useVoiceOpsActionCenter';
 export { useVoiceLiveOps } from './useVoiceLiveOps';
 export { useVoiceDeliveryRuntime } from './useVoiceDeliveryRuntime';