@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.510

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/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/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;