@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.531

package/dist/operationsRecord.d.ts

@@ -0,0 +1,370 @@
+import { Elysia } from "elysia";
+import { type MediaPipelineStatus } from "@absolutejs/media";
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import type { VoiceMediaPipelineReport } from "./mediaPipelineRoutes";
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskStore } from "./ops";
+import { type VoiceSessionReplay } from "./sessionReplay";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import { type VoiceTraceTimelineEvent, type VoiceTraceTimelineProviderSummary } from "./traceTimeline";
+import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary } from "./trace";
+export type VoiceOperationsRecordStatus = "failed" | "healthy" | "warning";
+export type VoiceOperationsRecordOutcome = {
+    assistantReplies: number;
+    complete: boolean;
+    escalated: boolean;
+    noAnswer: boolean;
+    transferred: boolean;
+    voicemail: boolean;
+};
+export type VoiceOperationsRecordAgentHandoff = {
+    at: number;
+    fromAgentId?: string;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    status?: string;
+    summary?: string;
+    targetAgentId?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordTool = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    status?: string;
+    toolCallId?: string;
+    toolName?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordTranscriptTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: string[];
+    id: string;
+    transcripts: string[];
+};
+export type VoiceOperationsRecordProviderDecision = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind?: string;
+    provider?: string;
+    reason?: string;
+    selectedProvider?: string;
+    status?: string;
+    surface?: string;
+    type: StoredVoiceTraceEvent["type"];
+    turnId?: string;
+};
+export type VoiceOperationsRecordProviderDecisionRecoveryStatus = "degraded" | "failed" | "none" | "recovered" | "selected";
+export type VoiceOperationsRecordProviderDecisionSummary = {
+    degraded: number;
+    errors: number;
+    fallbacks: number;
+    providers: string[];
+    recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    selected: number;
+    surfaces: string[];
+    total: number;
+};
+export type VoiceOperationsRecordAuditSummary = {
+    error: number;
+    events: StoredVoiceAuditEvent[];
+    skipped: number;
+    success: number;
+    total: number;
+};
+export type VoiceOperationsRecordReviewSummary = {
+    failed: number;
+    reviews: StoredVoiceCallReviewArtifact[];
+    total: number;
+};
+export type VoiceOperationsRecordTaskSummary = {
+    done: number;
+    inProgress: number;
+    open: number;
+    overdue: number;
+    tasks: StoredVoiceOpsTask[];
+    total: number;
+};
+export type VoiceOperationsRecordIntegrationEventSummary = {
+    delivered: number;
+    events: StoredVoiceIntegrationEvent[];
+    failed: number;
+    pending: number;
+    sinkDeliveries: number;
+    skipped: number;
+    total: number;
+};
+export type VoiceOperationsRecordGuardrailFinding = {
+    action?: string;
+    label?: string;
+    ruleId?: string;
+};
+export type VoiceOperationsRecordGuardrailDecision = {
+    allowed?: boolean;
+    at: number;
+    findings: VoiceOperationsRecordGuardrailFinding[];
+    metadata?: Record<string, unknown>;
+    proof?: string;
+    stage?: string;
+    status?: string;
+    toolName?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordGuardrailSummary = {
+    blocked: number;
+    decisions: VoiceOperationsRecordGuardrailDecision[];
+    passed: number;
+    stages: string[];
+    total: number;
+    warned: number;
+};
+export type VoiceOperationsRecordTelephonyMediaEvent = {
+    at: number;
+    audioBytes: number;
+    callSid?: string;
+    carrier?: string;
+    direction?: string;
+    event: string;
+    sequenceNumber?: string;
+    streamId?: string;
+};
+export type VoiceOperationsRecordTelephonyMediaSummary = {
+    audioBytes: number;
+    carriers: string[];
+    clears: number;
+    errors: number;
+    events: VoiceOperationsRecordTelephonyMediaEvent[];
+    inbound: number;
+    marks: number;
+    media: number;
+    outbound: number;
+    starts: number;
+    stops: number;
+    streamIds: string[];
+    total: number;
+};
+export type VoiceOperationsRecordMediaPipelineSummary = {
+    frames: number;
+    issueCodes: readonly string[];
+    jitterMs?: number;
+    processorGraphStatus?: MediaPipelineStatus;
+    qualityStatus: MediaPipelineStatus;
+    status: MediaPipelineStatus;
+    surface: string;
+    transportStatus?: MediaPipelineStatus;
+};
+export type VoiceOperationsRecordGuardrailAssertionInput = {
+    minBlocked?: number;
+    minDecisions?: number;
+    minPassed?: number;
+    minWarned?: number;
+    proofs?: string[];
+    ruleIds?: string[];
+    stages?: string[];
+    statuses?: string[];
+    toolNames?: string[];
+};
+export type VoiceOperationsRecordGuardrailAssertionReport = {
+    blocked: number;
+    decisions: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    proofs: string[];
+    ruleIds: string[];
+    stages: string[];
+    statuses: string[];
+    toolNames: string[];
+    warned: number;
+};
+export type VoiceOperationsRecordProviderRecoveryAssertionInput = {
+    minDegraded?: number;
+    minErrors?: number;
+    minFallbacks?: number;
+    minSelected?: number;
+    minTotal?: number;
+    recoveryStatus?: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    requiredFallbackProviders?: string[];
+    requiredProviders?: string[];
+    requiredReasonIncludes?: string[];
+    requiredSelectedProviders?: string[];
+    requiredStatuses?: string[];
+    requiredSurfaces?: string[];
+};
+export type VoiceOperationsRecordProviderRecoveryAssertionReport = {
+    degraded: number;
+    errors: number;
+    fallbacks: number;
+    issues: string[];
+    ok: boolean;
+    providers: string[];
+    recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    selected: number;
+    selectedProviders: string[];
+    statuses: string[];
+    surfaces: string[];
+    total: number;
+};
+export type VoiceOperationsRecord = {
+    audit?: VoiceOperationsRecordAuditSummary;
+    checkedAt: number;
+    guardrails: VoiceOperationsRecordGuardrailSummary;
+    handoffs: VoiceOperationsRecordAgentHandoff[];
+    integrationEvents?: VoiceOperationsRecordIntegrationEventSummary;
+    mediaPipeline?: VoiceOperationsRecordMediaPipelineSummary;
+    outcome: VoiceOperationsRecordOutcome;
+    providerDecisions: VoiceOperationsRecordProviderDecision[];
+    providerDecisionSummary: VoiceOperationsRecordProviderDecisionSummary;
+    providers: VoiceTraceTimelineProviderSummary[];
+    replay: VoiceSessionReplay;
+    reviews?: VoiceOperationsRecordReviewSummary;
+    sessionId: string;
+    status: VoiceOperationsRecordStatus;
+    summary: VoiceTraceSummary;
+    tasks?: VoiceOperationsRecordTaskSummary;
+    telephonyMedia: VoiceOperationsRecordTelephonyMediaSummary;
+    timeline: VoiceTraceTimelineEvent[];
+    tools: VoiceOperationsRecordTool[];
+    traceEvents: StoredVoiceTraceEvent[];
+    transcript: VoiceOperationsRecordTranscriptTurn[];
+};
+export type VoiceFailureReplayStatus = "degraded" | "failed" | "healthy" | "recovered";
+export type VoiceFailureReplayProviderStep = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind?: string;
+    provider?: string;
+    reason?: string;
+    selectedProvider?: string;
+    status?: string;
+    surface?: string;
+    turnId?: string;
+    userHeard: string[];
+};
+export type VoiceFailureReplayMediaStep = {
+    at: number;
+    audioBytes: number;
+    carrier?: string;
+    direction?: string;
+    event: string;
+    issue?: string;
+    streamId?: string;
+};
+export type VoiceFailureReplayTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: string[];
+    id: string;
+    media: VoiceFailureReplayMediaStep[];
+    providers: VoiceFailureReplayProviderStep[];
+    transcripts: string[];
+};
+export type VoiceFailureReplayReport = {
+    incidentMarkdown: string;
+    media: {
+        audioBytes: number;
+        clears: number;
+        errors: number;
+        issues: string[];
+        pipelineIssueCodes: readonly string[];
+        pipelineStatus?: MediaPipelineStatus;
+        steps: VoiceFailureReplayMediaStep[];
+        total: number;
+    };
+    ok: boolean;
+    operationsRecordHref?: string;
+    providers: {
+        degraded: number;
+        errors: number;
+        fallbacks: number;
+        recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+        selected: number;
+        steps: VoiceFailureReplayProviderStep[];
+        total: number;
+    };
+    sessionId: string;
+    status: VoiceFailureReplayStatus;
+    summary: {
+        callDurationMs?: number;
+        issues: string[];
+        userHeard: string[];
+    };
+    turns: VoiceFailureReplayTurn[];
+};
+export type VoiceFailureReplayOptions = {
+    operationsRecordHref?: string | ((input: {
+        record: VoiceOperationsRecord;
+        sessionId: string;
+    }) => string);
+};
+export type VoiceOperationsRecordOptions = {
+    audit?: VoiceAuditEventStore;
+    evaluation?: VoiceTraceEvaluationOptions;
+    events?: StoredVoiceTraceEvent[];
+    integrationEvents?: VoiceIntegrationEventStore;
+    mediaPipeline?: VoiceMediaPipelineReport;
+    redact?: VoiceTraceRedactionConfig;
+    reviews?: VoiceCallReviewStore;
+    sessionId: string;
+    store?: VoiceTraceEventStore;
+    tasks?: VoiceOpsTaskStore;
+};
+export type VoiceOperationsRecordRoutesOptions = Omit<VoiceOperationsRecordOptions, "sessionId" | "mediaPipeline"> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    incidentHtmlPath?: false | string;
+    incidentPath?: false | string;
+    mediaPipeline?: VoiceMediaPipelineReport | ((input: {
+        sessionId: string;
+    }) => Promise<VoiceMediaPipelineReport | undefined> | VoiceMediaPipelineReport | undefined);
+    name?: string;
+    path?: string;
+    render?: (record: VoiceOperationsRecord) => string | Promise<string>;
+    renderIncidentMarkdown?: (record: VoiceOperationsRecord) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceOperationsRecord: (options: VoiceOperationsRecordOptions) => Promise<VoiceOperationsRecord>;
+export declare const evaluateVoiceOperationsRecordGuardrails: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordGuardrailAssertionInput) => VoiceOperationsRecordGuardrailAssertionReport;
+export declare const assertVoiceOperationsRecordGuardrails: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordGuardrailAssertionInput) => VoiceOperationsRecordGuardrailAssertionReport;
+export declare const evaluateVoiceOperationsRecordProviderRecovery: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordProviderRecoveryAssertionInput) => VoiceOperationsRecordProviderRecoveryAssertionReport;
+export declare const assertVoiceOperationsRecordProviderRecovery: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordProviderRecoveryAssertionInput) => VoiceOperationsRecordProviderRecoveryAssertionReport;
+export declare const buildVoiceFailureReplay: (record: VoiceOperationsRecord, options?: VoiceFailureReplayOptions) => VoiceFailureReplayReport;
+export declare const renderVoiceFailureReplayMarkdown: (report: Omit<VoiceFailureReplayReport, "incidentMarkdown"> | VoiceFailureReplayReport) => string;
+export declare const renderVoiceOperationsRecordIncidentMarkdown: (record: VoiceOperationsRecord) => string;
+export declare const renderVoiceOperationsRecordGuardrailMarkdown: (record: VoiceOperationsRecord) => string;
+export declare const renderVoiceOperationsRecordHTML: (record: VoiceOperationsRecord, options?: {
+    incidentHref?: string;
+    title?: string;
+}) => string;
+export declare const createVoiceOperationsRecordRoutes: (options: VoiceOperationsRecordRoutesOptions) => 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/ops.d.ts

@@ -1,13 +1,13 @@
-import type { VoiceCallDisposition, VoiceSessionRecord, VoiceSessionSummary } from './types';
-import type { StoredVoiceCallReviewArtifact } from './testing/review';
-export type VoiceOpsTaskStatus = 'open' | 'in-progress' | 'done';
-export type VoiceOpsTaskKind = 'appointment-booking' | 'callback' | 'escalation' | 'lead-qualification' | 'transfer-check' | 'retry-review' | 'support-triage';
-export type VoiceOpsTaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+import type { VoiceCallDisposition, VoiceSessionRecord, VoiceSessionSummary } from "./types";
+import type { StoredVoiceCallReviewArtifact } from "./testing/review";
+export type VoiceOpsTaskStatus = "open" | "in-progress" | "done";
+export type VoiceOpsTaskKind = "appointment-booking" | "callback" | "escalation" | "lead-qualification" | "transfer-check" | "retry-review" | "support-triage";
+export type VoiceOpsTaskPriority = "low" | "normal" | "high" | "urgent";
 export type VoiceOpsTaskHistoryEntry = {
     actor: string;
     at: number;
     detail?: string;
-    type: 'created' | 'assigned' | 'started' | 'claimed' | 'heartbeat' | 'failed' | 'dead-lettered' | 'policy-applied' | 'sla-breached' | 'completed' | 'reopened' | 'requeued';
+    type: "created" | "assigned" | "started" | "claimed" | "heartbeat" | "failed" | "dead-lettered" | "policy-applied" | "sla-breached" | "completed" | "reopened" | "requeued";
 };
 export type VoiceOpsTask = {
     assignee?: string;
@@ -45,7 +45,7 @@ export type VoiceExternalObjectMap = {
     provider: string;
     sinkId?: string;
     sourceId: string;
-    sourceType: 'session' | 'review' | 'task' | 'event';
+    sourceType: "session" | "review" | "task" | "event";
     updatedAt: number;
 };
 export type StoredVoiceExternalObjectMap = VoiceExternalObjectMap;
@@ -67,7 +67,7 @@ export type VoiceExternalObjectMapStore<TMapping extends StoredVoiceExternalObje
         provider: string;
         sinkId?: string;
         sourceId: string;
-        sourceType?: VoiceExternalObjectMap['sourceType'];
+        sourceType?: VoiceExternalObjectMap["sourceType"];
     }) => Promise<TMapping | undefined> | TMapping | undefined;
     get: (id: string) => Promise<TMapping | undefined> | TMapping | undefined;
     list: () => Promise<TMapping[]> | TMapping[];
@@ -96,7 +96,7 @@ export type VoiceOpsTaskSummary = {
     topTargets: Array<[string, number]>;
     total: number;
 };
-export type VoiceOpsTaskAgeBucket = 'fresh' | 'aging' | 'due-soon' | 'overdue' | 'stale';
+export type VoiceOpsTaskAgeBucket = "fresh" | "aging" | "due-soon" | "overdue" | "stale";
 export type VoiceOpsTaskAssigneeAnalytics = {
     assignee: string;
     averageCompletionMs?: number;
@@ -161,9 +161,9 @@ export type VoiceOpsTaskAnalyticsOptions = {
     dueSoonMs?: number;
     staleMs?: number;
 };
-export type VoiceIntegrationEventType = 'call.completed' | 'review.saved' | 'task.created' | 'task.updated' | 'task.sla_breached';
+export type VoiceIntegrationEventType = "call.completed" | "review.saved" | "task.created" | "task.updated" | "task.sla_breached";
 export type VoiceOpsSLABreachPolicy = {
-    action?: 'event' | 'event-and-task' | 'task';
+    action?: "event" | "event-and-task" | "task";
     assignee?: string;
     description?: string;
     dueInMs?: number;
@@ -173,7 +173,7 @@ export type VoiceOpsSLABreachPolicy = {
     recommendedAction?: string;
     title?: string;
 };
-export type VoiceIntegrationDeliveryStatus = 'pending' | 'delivered' | 'failed' | 'skipped';
+export type VoiceIntegrationDeliveryStatus = "pending" | "delivered" | "failed" | "skipped";
 export type VoiceIntegrationSinkDelivery = {
     attempts: number;
     deliveredAt?: number;

package/dist/opsActionAuditRoutes.d.ts

@@ -0,0 +1,99 @@
+import { Elysia } from "elysia";
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import { type VoiceTraceEventStore } from "./trace";
+export type VoiceOpsActionAuditRecord = {
+    actionId: string;
+    body?: unknown;
+    error?: string;
+    ok: boolean;
+    ranAt: number;
+    status: number;
+};
+export type VoiceOpsActionAuditRoutesOptions = {
+    audit?: VoiceAuditEventStore;
+    historyHtmlPath?: false | string;
+    historyPath?: false | string;
+    name?: string;
+    path?: string;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceOpsActionHistoryEntry = {
+    actionId: string;
+    at: number;
+    error?: string;
+    eventId: string;
+    ok: boolean;
+    status?: number;
+    traceId?: string;
+};
+export type VoiceOpsActionHistoryReport = {
+    checkedAt: number;
+    entries: VoiceOpsActionHistoryEntry[];
+    failed: number;
+    passed: number;
+    total: number;
+};
+export declare const recordVoiceOpsActionAudit: (record: VoiceOpsActionAuditRecord, options: Pick<VoiceOpsActionAuditRoutesOptions, "audit" | "trace">) => Promise<{
+    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+        at: number;
+        id: string;
+    }) | undefined;
+    ok: boolean;
+    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+        id: string;
+    }) | undefined;
+}>;
+export declare const createVoiceOpsActionAuditRoutes: (options: VoiceOpsActionAuditRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+                        at: number;
+                        id: string;
+                    }) | undefined;
+                    ok: boolean;
+                    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+                        id: string;
+                    }) | undefined;
+                } | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const buildVoiceOpsActionHistoryReport: (options: Pick<VoiceOpsActionAuditRoutesOptions, "audit">) => Promise<VoiceOpsActionHistoryReport>;
+export declare const renderVoiceOpsActionHistoryHTML: (report: VoiceOpsActionHistoryReport) => string;

package/dist/opsConsoleRoutes.d.ts

@@ -1,8 +1,9 @@
-import { Elysia } from 'elysia';
-import { type VoiceQualityReport } from './qualityRoutes';
-import { type VoiceRoutingEvent } from './resilienceRoutes';
-import { type VoiceSessionListItem } from './sessionReplay';
-import { summarizeVoiceTrace, type VoiceTraceEventStore } from './trace';
+import { Elysia } from "elysia";
+import { type VoiceDeliverySinkReport, type VoiceDeliverySinkRoutesOptions } from "./deliverySinkRoutes";
+import { type VoiceQualityReport } from "./qualityRoutes";
+import { type VoiceRoutingEvent } from "./resilienceRoutes";
+import { type VoiceSessionListItem } from "./sessionReplay";
+import { summarizeVoiceTrace, type VoiceTraceEventStore } from "./trace";
 export type VoiceOpsConsoleLink = {
     description?: string;
     href: string;
@@ -17,6 +18,7 @@ export type VoiceOpsConsoleReport = {
         total: number;
     };
     links: VoiceOpsConsoleLink[];
+    deliverySinks?: VoiceDeliverySinkReport;
     providers: {
         degraded: number;
         healthy: number;
@@ -34,6 +36,7 @@ export type VoiceOpsConsoleReport = {
 };
 export type VoiceOpsConsoleRoutesOptions = {
     headers?: HeadersInit;
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
     links?: VoiceOpsConsoleLink[];
     llmProviders?: readonly string[];
     name?: string;

package/dist/opsPresets.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRules, VoiceOpsSLABreachPolicy } from './ops';
-export type VoiceOpsPresetName = 'support-default' | 'sales-default' | 'collections-default';
+import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRules, VoiceOpsSLABreachPolicy } from "./ops";
+export type VoiceOpsPresetName = "support-default" | "sales-default" | "collections-default";
 export type VoiceResolvedOpsPreset = {
     assignmentRules: VoiceOpsTaskAssignmentRules;
     description: string;