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

package/README.md

@@ -68,7 +68,7 @@ Use this checklist when a buyer asks, "How do I know this replaces a hosted voic
 | Can I prove provider fallback and latency? | provider contract matrix, provider status UI, `/turn-latency`, `/live-latency` | Provider choice, fallback behavior, server turn timing, browser p50/p95 timing |
 | Can operators intervene safely? | live-ops routes, action center, ops action audit routes, operations record | Pause/resume/takeover, injected instructions, operator action audit trail |
 | Can I run outbound campaigns? | `/voice/campaigns`, `/voice/campaigns/observability`, `/api/voice/campaigns/readiness-proof` | Recipient import evidence, consent/dedupe checks, scheduling policy, worker-safe attempts |
-| Can I handle post-call workflow? | reviews, tasks, integration events, outcome contracts, operations record | Summary/review artifacts, task creation, webhook/sink delivery, matched session proof |
+| Can I handle post-call workflow? | `createVoicePostCallAnalysisRoutes(...)`, reviews, tasks, integration events, outcome contracts, operations record | Extracted-field proof, task creation, webhook/sink delivery, matched session proof |
 | Can I keep data in my infrastructure? | `/data-control`, `/data-control/audit.md`, retention dry-run/apply routes | Customer-owned storage, redaction, audit export, guarded deletion, zero-retention planning |
 | Can I prove release readiness? | `/production-readiness`, `/ops-recovery`, delivery runtime, readiness profiles | Deploy gates for session health, audits, delivery queues, provider/campaign/phone proof |
 
@@ -82,6 +82,37 @@ For a demo, the fastest convincing path is:
 
 If those five surfaces are green and linked, the buyer can see the core difference from Vapi-style hosted orchestration: the operational proof lives inside the app, not in a vendor dashboard.
 
+## Post-Call Analysis Proof
+
+Use `createVoicePostCallAnalysisRoutes(...)` when the hosted-platform feature you need is call analysis plus follow-up proof. It validates that required extracted fields exist, expected ops tasks were created, integration/webhook events delivered, and the report links back to `/voice-operations/:sessionId`.
+
+```ts
+import { createVoicePostCallAnalysisRoutes } from '@absolutejs/voice';
+
+app.use(
+	createVoicePostCallAnalysisRoutes({
+		path: '/api/voice/post-call-analysis',
+		operationRecordBasePath: '/voice-operations/:sessionId',
+		reviews: runtime.reviews,
+		tasks: runtime.tasks,
+		integrationEvents: runtime.events,
+		source: ({ reviewId, sessionId }) => ({
+			reviewId,
+			sessionId,
+			// Use your own extractor output here, for example fields persisted from an LLM/tool result.
+			extractedFields: loadExtractedPostCallFields(reviewId ?? sessionId)
+		}),
+		fields: [
+			{ path: 'review.postCall.target', label: 'customer target' },
+			{ path: 'customerId' },
+			{ path: 'category' }
+		],
+		requiredTaskKinds: ['support-triage'],
+		requireDeliveredIntegrationEvent: true
+	})
+);
+```
+
 ## Use-Case Recipe: Support Triage
 
 Use this path when you want a Vapi-style support assistant that can answer web or phone calls, look up customer context, route billing issues to a specialist, create follow-up work, and leave one debuggable call record. It is a recipe over primitives, not a support app kit.

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/package.json

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