@absolutejs/voice 0.0.22-beta.52 → 0.0.22-beta.520

package/dist/browserCallProfiles.d.ts

@@ -0,0 +1,120 @@
+import { Elysia } from "elysia";
+export type VoiceBrowserCallProfileStatus = "empty" | "fail" | "pass" | "stale" | "warn";
+export type VoiceBrowserCallProfileFrameworkSummary = {
+    messageCount?: number;
+    openSockets?: number;
+    receivedBytes?: number;
+    sentBytes?: number;
+};
+export type VoiceBrowserCallProfileFrameworkEvidence = {
+    error?: string;
+    framework: string;
+    ok?: boolean;
+    summary?: VoiceBrowserCallProfileFrameworkSummary;
+    url?: string;
+};
+export type VoiceBrowserCallProfileSummary = {
+    failedFrameworks: string[];
+    openSockets: number;
+    passedFrameworks: string[];
+    receivedBytes: number;
+    sentBytes: number;
+    totalFrameworks: number;
+    totalMessages: number;
+};
+export type VoiceBrowserCallProfileReportInput = {
+    ageMs?: number;
+    baseUrl?: string;
+    frameworks?: string[];
+    freshUntil?: string;
+    generatedAt?: string;
+    maxAgeMs?: number;
+    now?: Date | number | string;
+    ok?: boolean;
+    outputDir?: string;
+    profileId?: string;
+    results?: VoiceBrowserCallProfileFrameworkEvidence[];
+    runId?: string;
+    source?: string;
+    status?: VoiceBrowserCallProfileStatus;
+    summary?: Partial<VoiceBrowserCallProfileSummary> & VoiceBrowserCallProfileFrameworkSummary;
+};
+export type VoiceBrowserCallProfileReport = {
+    ageMs?: number;
+    baseUrl?: string;
+    frameworks: string[];
+    freshUntil?: string;
+    generatedAt: string;
+    maxAgeMs: number;
+    ok: boolean;
+    outputDir?: string;
+    profileId: string;
+    results: VoiceBrowserCallProfileFrameworkEvidence[];
+    runId?: string;
+    source: string;
+    status: VoiceBrowserCallProfileStatus;
+    summary: VoiceBrowserCallProfileSummary;
+};
+export type VoiceBrowserCallProfileAssertionInput = {
+    maxAgeMs?: number;
+    minMessageCountPerFramework?: number;
+    minOpenSocketsPerFramework?: number;
+    minSentBytesPerFramework?: number;
+    requireAllFrameworksPass?: boolean;
+    requiredFrameworks?: string[];
+};
+export type VoiceBrowserCallProfileAssertionReport = {
+    failedFrameworks: string[];
+    issues: string[];
+    ok: boolean;
+    passedFrameworks: string[];
+    status: VoiceBrowserCallProfileStatus;
+    summary: VoiceBrowserCallProfileSummary;
+};
+export type VoiceBrowserCallProfileRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    jsonPath?: string;
+    markdownPath?: false | string;
+    maxAgeMs?: number;
+    name?: string;
+    source?: (() => Promise<VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput> | VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput) | VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput;
+    title?: string;
+};
+export declare const buildVoiceBrowserCallProfileReport: (input?: VoiceBrowserCallProfileReportInput) => VoiceBrowserCallProfileReport;
+export declare const evaluateVoiceBrowserCallProfileEvidence: (report: VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput, input?: VoiceBrowserCallProfileAssertionInput) => VoiceBrowserCallProfileAssertionReport;
+export declare const assertVoiceBrowserCallProfileEvidence: (report: VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput, input?: VoiceBrowserCallProfileAssertionInput) => VoiceBrowserCallProfileAssertionReport;
+export declare const renderVoiceBrowserCallProfileMarkdown: (report: VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceBrowserCallProfileHTML: (report: VoiceBrowserCallProfileReport | VoiceBrowserCallProfileReportInput, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceBrowserCallProfileRoutes: (options?: VoiceBrowserCallProfileRoutesOptions) => 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/browserMediaRoutes.d.ts

@@ -0,0 +1,62 @@
+import { Elysia } from "elysia";
+import type { MediaWebRTCStatsReport, MediaWebRTCStreamContinuityReport } from "@absolutejs/media";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceBrowserMediaStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceBrowserMediaSample = {
+    at: number;
+    continuity?: MediaWebRTCStreamContinuityReport;
+    report: MediaWebRTCStatsReport;
+    scenarioId?: string;
+    sessionId: string;
+    traceId?: string;
+};
+export type VoiceBrowserMediaReport = {
+    checkedAt: number;
+    latest?: VoiceBrowserMediaSample;
+    recent: VoiceBrowserMediaSample[];
+    status: VoiceBrowserMediaStatus;
+    stale: boolean;
+    total: number;
+};
+export type VoiceBrowserMediaRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    maxAgeMs?: number;
+    name?: string;
+    path?: string;
+    store: VoiceTraceEventStore;
+    title?: string;
+};
+export declare const summarizeVoiceBrowserMedia: (options: Pick<VoiceBrowserMediaRoutesOptions, "maxAgeMs" | "store">) => Promise<VoiceBrowserMediaReport>;
+export declare const getLatestVoiceBrowserMediaReport: (options: Pick<VoiceBrowserMediaRoutesOptions, "maxAgeMs" | "store">) => Promise<MediaWebRTCStatsReport | undefined>;
+export declare const renderVoiceBrowserMediaHTML: (report: VoiceBrowserMediaReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceBrowserMediaRoutes: (options: VoiceBrowserMediaRoutesOptions) => 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/calendarAdapter.d.ts

@@ -0,0 +1,47 @@
+import type { VoiceCalendarBookedRange, VoiceCalendarBusinessHours, VoiceCalendarSlot } from "./calendarSlots";
+export type VoiceCalendarAppointment = {
+    id: string;
+    calendarId: string;
+    startMs: number;
+    endMs: number;
+    title?: string;
+    attendees?: string[];
+    notes?: string;
+    metadata?: Record<string, string>;
+    createdAt: number;
+    status: "scheduled" | "cancelled" | "completed" | "no-show";
+};
+export type VoiceCalendarAvailabilityQuery = {
+    calendarId: string;
+    fromMs: number;
+    toMs: number;
+    durationMinutes: number;
+    bufferMinutes?: number;
+    granularityMinutes?: number;
+    maxSlots?: number;
+};
+export type VoiceCalendarBookInput = {
+    calendarId: string;
+    startMs: number;
+    endMs: number;
+    title?: string;
+    attendees?: string[];
+    notes?: string;
+    metadata?: Record<string, string>;
+};
+export type VoiceCalendarAdapter = {
+    readonly providerName: string;
+    listAvailability(query: VoiceCalendarAvailabilityQuery): Promise<VoiceCalendarSlot[]>;
+    book(input: VoiceCalendarBookInput): Promise<VoiceCalendarAppointment>;
+    cancel(appointmentId: string): Promise<VoiceCalendarAppointment | null>;
+    get(appointmentId: string): Promise<VoiceCalendarAppointment | null>;
+    reschedule(appointmentId: string, nextStartMs: number, nextEndMs: number): Promise<VoiceCalendarAppointment | null>;
+};
+export type CreateVoiceInMemoryCalendarAdapterOptions = {
+    businessHours: VoiceCalendarBusinessHours[];
+    timezone?: string;
+    bookedRanges?: VoiceCalendarBookedRange[];
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare const createVoiceInMemoryCalendarAdapter: (options: CreateVoiceInMemoryCalendarAdapterOptions) => VoiceCalendarAdapter;

package/dist/calendarSlots.d.ts

@@ -0,0 +1,35 @@
+export type VoiceCalendarBusinessHours = {
+    weekday: number;
+    start: string;
+    end: string;
+};
+export type VoiceCalendarBlackout = {
+    date: string;
+    reason?: string;
+};
+export type VoiceCalendarBookedRange = {
+    startMs: number;
+    endMs: number;
+};
+export type VoiceCalendarSlot = {
+    startMs: number;
+    endMs: number;
+    durationMinutes: number;
+};
+export type GenerateVoiceCalendarSlotsInput = {
+    fromMs: number;
+    toMs: number;
+    durationMinutes: number;
+    bufferMinutes?: number;
+    granularityMinutes?: number;
+    timezone?: string;
+    businessHours: VoiceCalendarBusinessHours[];
+    blackoutDates?: VoiceCalendarBlackout[];
+    bookedRanges?: VoiceCalendarBookedRange[];
+    maxSlots?: number;
+};
+export declare const generateVoiceCalendarSlots: (input: GenerateVoiceCalendarSlotsInput) => VoiceCalendarSlot[];
+export declare const summarizeVoiceCalendarSlot: (slot: VoiceCalendarSlot, options?: {
+    timezone?: string;
+    locale?: string;
+}) => string;

package/dist/callDebugger.d.ts

@@ -0,0 +1,66 @@
+import { Elysia } from "elysia";
+import { type VoiceFailureReplayReport, type VoiceOperationsRecord, type VoiceOperationsRecordOptions } from "./operationsRecord";
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from "./trace";
+import { type VoiceSessionSnapshot, type VoiceSessionSnapshotRouteSource } from "./sessionSnapshot";
+export type VoiceCallDebuggerReport = {
+    checkedAt: number;
+    failureReplay: VoiceFailureReplayReport;
+    incidentMarkdown: string;
+    operationsRecord: VoiceOperationsRecord;
+    sessionId: string;
+    snapshot: VoiceSessionSnapshot;
+    status: "failed" | "healthy" | "warning";
+};
+export type VoiceCallDebuggerRoutesOptions = Omit<VoiceOperationsRecordOptions, "sessionId"> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    incidentPath?: false | string;
+    name?: string;
+    operationsRecordHref?: string | ((input: {
+        sessionId: string;
+    }) => string | undefined);
+    path?: string;
+    render?: (report: VoiceCallDebuggerReport) => string | Promise<string>;
+    resolveSessionId?: (input: {
+        events: readonly StoredVoiceTraceEvent[];
+        request: Request;
+        requestedSessionId: string;
+        store?: VoiceTraceEventStore;
+    }) => Promise<string | undefined> | string | undefined;
+    snapshot?: VoiceSessionSnapshotRouteSource;
+    title?: string;
+};
+export declare const resolveLatestVoiceCallDebuggerSessionId: (events: readonly StoredVoiceTraceEvent[]) => string | undefined;
+export declare const buildVoiceCallDebuggerReport: (options: VoiceCallDebuggerRoutesOptions, input: {
+    request: Request;
+    sessionId: string;
+}) => Promise<VoiceCallDebuggerReport>;
+export declare const renderVoiceCallDebuggerHTML: (report: VoiceCallDebuggerReport, options?: Pick<VoiceCallDebuggerRoutesOptions, "title">) => string;
+export declare const createVoiceCallDebuggerRoutes: (options: VoiceCallDebuggerRoutesOptions) => 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/callDisposition.d.ts

@@ -0,0 +1,38 @@
+export type VoiceCallDispositionTaxonomy = "sales" | "support" | "collections" | "survey" | "custom";
+export type VoiceCallDispositionDefinition = {
+    code: string;
+    label: string;
+    outcome: "positive" | "neutral" | "negative" | "no-contact";
+    retryable: boolean;
+    taxonomy?: VoiceCallDispositionTaxonomy;
+};
+export declare const DEFAULT_VOICE_CALL_DISPOSITIONS: VoiceCallDispositionDefinition[];
+export type VoiceCallDispositionTag = {
+    sessionId: string;
+    code: string;
+    taggedAt: number;
+    note?: string;
+};
+export type CreateVoiceCallDispositionTaggerOptions = {
+    taxonomy?: VoiceCallDispositionDefinition[];
+    allowMultiple?: boolean;
+    now?: () => number;
+};
+export declare const createVoiceCallDispositionTagger: (options?: CreateVoiceCallDispositionTaggerOptions) => {
+    definitionFor: (code: string) => VoiceCallDispositionDefinition | null;
+    definitions: VoiceCallDispositionDefinition[];
+    listAll: () => VoiceCallDispositionTag[];
+    listForSession: (sessionId: string) => VoiceCallDispositionTag[];
+    summarize: () => {
+        byCode: {
+            [k: string]: number;
+        };
+        byOutcome: Record<"negative" | "neutral" | "positive" | "no-contact", number>;
+        retryablePct: number;
+        totalSessions: number;
+        totalTagged: number;
+    };
+    tag: (sessionId: string, code: string, note?: string) => VoiceCallDispositionTag;
+    untag: (sessionId: string, code?: string) => number;
+};
+export type VoiceCallDispositionTagger = ReturnType<typeof createVoiceCallDispositionTagger>;

package/dist/callQuota.d.ts

@@ -0,0 +1,54 @@
+export type VoiceCallQuotaTier = {
+    burstAllowance?: number;
+    customerId: string;
+    monthlyMinutes?: number;
+    reservedConcurrent: number;
+};
+export type VoiceCallReservation = {
+    callId: string;
+    customerId: string;
+    release: () => Promise<void> | void;
+    reservedAt: number;
+};
+export type VoiceCallQuotaRejection = {
+    customerId: string;
+    reason: "concurrency-exceeded" | "customer-not-found" | "monthly-minutes-exceeded";
+    retryAfterMs?: number;
+};
+export type VoiceCallQuotaResult = {
+    ok: false;
+    rejection: VoiceCallQuotaRejection;
+} | {
+    ok: true;
+    reservation: VoiceCallReservation;
+};
+export type VoiceCallQuota = {
+    describe: (customerId: string) => Promise<undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    }> | (undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    });
+    recordMinutes: (input: {
+        callId?: string;
+        customerId: string;
+        minutes: number;
+    }) => Promise<void> | void;
+    reserve: (input: {
+        callId: string;
+        customerId: string;
+    }) => Promise<VoiceCallQuotaResult> | VoiceCallQuotaResult;
+};
+export type CreateInMemoryVoiceCallQuotaOptions = {
+    /** When provided, treat any customer not in the map as denied with 'customer-not-found'. */
+    strict?: boolean;
+    tiers: VoiceCallQuotaTier[];
+};
+export declare const createInMemoryVoiceCallQuota: (options: CreateInMemoryVoiceCallQuotaOptions) => VoiceCallQuota;

package/dist/callScorecard.d.ts

@@ -0,0 +1,53 @@
+export type VoiceScorecardCriterion = {
+    id: string;
+    label: string;
+    weight: number;
+    section?: string;
+    passingScore?: number;
+    required?: boolean;
+};
+export type VoiceScorecardRubric = {
+    id: string;
+    label: string;
+    scaleMax?: number;
+    passingGrade?: number;
+    criteria: VoiceScorecardCriterion[];
+};
+export type VoiceScorecardCriterionResult = {
+    criterionId: string;
+    score: number;
+    weight: number;
+    rationale?: string;
+    passed: boolean;
+};
+export type VoiceScorecard = {
+    rubricId: string;
+    sessionId: string;
+    agentId?: string;
+    reviewer: "human" | "llm" | "hybrid";
+    reviewerId?: string;
+    createdAt: number;
+    scaleMax: number;
+    passingGrade: number;
+    results: VoiceScorecardCriterionResult[];
+    weightedScore: number;
+    grade: "pass" | "fail" | "needs-review";
+    sectionScores: Record<string, number>;
+    failedRequiredCriteria: string[];
+    comments?: string;
+};
+export type BuildVoiceCallScorecardInput = {
+    rubric: VoiceScorecardRubric;
+    sessionId: string;
+    agentId?: string;
+    reviewer: VoiceScorecard["reviewer"];
+    reviewerId?: string;
+    scores: Record<string, {
+        score: number;
+        rationale?: string;
+    }>;
+    comments?: string;
+    now?: () => number;
+};
+export declare const buildVoiceCallScorecard: (input: BuildVoiceCallScorecardInput) => VoiceScorecard;
+export declare const DEFAULT_VOICE_SALES_RUBRIC: VoiceScorecardRubric;

package/dist/callerCRMLinker.d.ts

@@ -0,0 +1,29 @@
+import type { VoiceCallerIdentity } from "./callerMemory";
+import type { VoiceCRMContactSummary, VoiceCRMContract } from "./crmContract";
+export type VoiceCallerCRMLinkRecord = {
+    callerKey: string;
+    vendor: string;
+    contactId: string;
+    contact: VoiceCRMContactSummary;
+    resolvedAt: number;
+    source: "memory" | "phone-lookup" | "email-lookup" | "manual";
+};
+export type VoiceCallerCRMLinkCacheStore = {
+    get(key: string): Promise<VoiceCallerCRMLinkRecord | null> | VoiceCallerCRMLinkRecord | null;
+    put(record: VoiceCallerCRMLinkRecord): Promise<void> | void;
+    remove(key: string): Promise<boolean> | boolean;
+};
+export type CreateVoiceCallerCRMLinkerOptions = {
+    contract: VoiceCRMContract;
+    cache?: VoiceCallerCRMLinkCacheStore;
+    staleAfterMs?: number;
+    now?: () => number;
+};
+export declare const createInMemoryVoiceCallerCRMLinkCache: () => VoiceCallerCRMLinkCacheStore;
+export declare const createVoiceCallerCRMLinker: (options: CreateVoiceCallerCRMLinkerOptions) => {
+    associate: (identity: VoiceCallerIdentity, contact: VoiceCRMContactSummary) => Promise<VoiceCallerCRMLinkRecord>;
+    contract: VoiceCRMContract;
+    invalidate: (identity: VoiceCallerIdentity) => Promise<boolean>;
+    resolve: (identity: VoiceCallerIdentity) => Promise<VoiceCallerCRMLinkRecord | null>;
+};
+export type VoiceCallerCRMLinker = ReturnType<typeof createVoiceCallerCRMLinker>;

package/dist/callerMemory.d.ts

@@ -0,0 +1,37 @@
+import type { Transcript, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceAssistantMemoryNamespaceInput } from "./assistantMemory";
+export type VoiceCallerIdentity = {
+    email?: string;
+    externalId?: string;
+    phone?: string;
+};
+export type VoiceCallerMemorySnapshot = {
+    facts: Record<string, string>;
+    identity: VoiceCallerIdentity;
+    lastSessionAt: number;
+    openActions: string[];
+    summary: string;
+};
+export declare const VOICE_CALLER_MEMORY_KEY = "caller-memory-snapshot";
+export declare const buildVoiceCallerMemoryNamespace: (identity: VoiceCallerIdentity | undefined, prefix?: string) => string;
+export type CreateVoiceCallerMemoryNamespaceOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    identifyCaller: (input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<VoiceCallerIdentity | undefined> | VoiceCallerIdentity | undefined;
+    prefix?: string;
+};
+export declare const createVoiceCallerMemoryNamespace: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: CreateVoiceCallerMemoryNamespaceOptions<TContext, TSession>) => (input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<string>;
+export type VoiceCallerMemoryCompletion = (input: {
+    prompt: string;
+    systemPrompt?: string;
+}) => Promise<string>;
+export type SummarizeVoiceCallerTranscriptOptions = {
+    completion: VoiceCallerMemoryCompletion;
+    previousSnapshot?: VoiceCallerMemorySnapshot;
+    systemPrompt?: string;
+};
+export type VoiceCallerMemorySummarizerInput = {
+    identity: VoiceCallerIdentity;
+    options: SummarizeVoiceCallerTranscriptOptions;
+    transcripts?: Transcript[];
+    turns: VoiceTurnRecord[];
+};
+export declare const summarizeVoiceCallerTranscript: (input: VoiceCallerMemorySummarizerInput) => Promise<VoiceCallerMemorySnapshot>;

package/dist/callingWindow.d.ts

@@ -0,0 +1,26 @@
+export type VoiceCallingDayKey = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+export type VoiceCallingTimeRange = {
+    start: string;
+    end: string;
+};
+export type VoiceCallingWindowOptions = {
+    timezone?: string;
+    allowedDays?: VoiceCallingDayKey[];
+    allowedHours?: VoiceCallingTimeRange | VoiceCallingTimeRange[];
+    blockedDates?: string[];
+    perDayHours?: Partial<Record<VoiceCallingDayKey, VoiceCallingTimeRange[]>>;
+    now?: () => Date;
+};
+export type VoiceCallingWindowVerdict = {
+    allowed: boolean;
+    reason?: "outside-hours" | "blocked-date" | "outside-day";
+    nextWindowAt?: number;
+};
+export declare const createVoiceCallingWindow: (options?: VoiceCallingWindowOptions) => {
+    allowedDays: VoiceCallingDayKey[];
+    canCallNow(at?: Date): VoiceCallingWindowVerdict;
+    nextWindowOpensAt(at?: Date): number;
+    timezone: string | undefined;
+};
+export type VoiceCallingWindow = ReturnType<typeof createVoiceCallingWindow>;
+export declare const VOICE_TCPA_DEFAULT_WINDOW: VoiceCallingWindowOptions;