@absolutejs/voice 0.0.22-beta.12 → 0.0.22-beta.120

package/dist/angular/voice-app-kit-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceAppKitStatusClientOptions } from '../client/appKitStatus';
+import type { VoiceAppKitStatusReport } from '../appKit';
+export declare class VoiceAppKitStatusService {
+    connect(path?: string, options?: VoiceAppKitStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceAppKitStatusReport | undefined>;
+        report: import("@angular/core").Signal<VoiceAppKitStatusReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-campaign-dialer-proof.service.d.ts

@@ -0,0 +1,14 @@
+import { type VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../campaignDialers';
+export declare class VoiceCampaignDialerProofService {
+    connect(path?: string, options?: VoiceCampaignDialerProofClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+        report: import("@angular/core").Signal<VoiceCampaignDialerProofReport | undefined>;
+        runProof: () => Promise<VoiceCampaignDialerProofReport>;
+        status: import("@angular/core").Signal<VoiceCampaignDialerProofStatus | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-ops-status.component.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { type VoiceOpsStatusViewModel } from '../client/opsStatusWidget';
+export declare class VoiceOpsStatusComponent implements OnDestroy, OnInit {
+    description?: string;
+    includeLinks: boolean;
+    intervalMs?: number;
+    path: string;
+    title?: string;
+    private cleanup;
+    private store?;
+    model: import("@angular/core").WritableSignal<VoiceOpsStatusViewModel>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private options;
+}

package/dist/angular/voice-provider-capabilities.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderCapabilitiesClientOptions } from '../client/providerCapabilities';
+import type { VoiceProviderCapabilityReport } from '../providerCapabilities';
+export declare class VoiceProviderCapabilitiesService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        report: import("@angular/core").Signal<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-provider-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare class VoiceProviderStatusService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        providers: import("@angular/core").Signal<VoiceProviderHealthSummary<TProvider>[]>;
+        refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-routing-status.service.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceRoutingStatusClientOptions } from '../client/routingStatus';
+export declare class VoiceRoutingStatusService {
+    connect(path?: string, options?: VoiceRoutingStatusClientOptions): {
+        close: () => void;
+        decision: import("@angular/core").Signal<import("..").VoiceRoutingEvent | null>;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-stream.service.d.ts

@@ -8,6 +8,8 @@ export declare class VoiceStreamService {
             turnId?: string;
         }[]>;
         assistantTexts: import("@angular/core").Signal<string[]>;
+        call: import("@angular/core").Signal<import("..").VoiceCallLifecycleState | null>;
+        callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
         close: () => void;
         endTurn: () => void;
         error: import("@angular/core").Signal<string | null>;

package/dist/angular/voice-trace-timeline.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTraceTimelineClientOptions } from '../client/traceTimeline';
+import type { VoiceTraceTimelineReport } from '../traceTimeline';
+export declare class VoiceTraceTimelineService {
+    connect(path?: string, options?: VoiceTraceTimelineClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTraceTimelineReport | null>;
+        report: import("@angular/core").Signal<VoiceTraceTimelineReport | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-latency.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceTurnLatencyClientOptions } from '../client/turnLatency';
+import type { VoiceTurnLatencyReport } from '../turnLatency';
+export declare class VoiceTurnLatencyService {
+    connect(path?: string, options?: VoiceTurnLatencyClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnLatencyReport | undefined>;
+        runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-quality.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTurnQualityClientOptions } from '../client/turnQuality';
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export declare class VoiceTurnQualityService {
+    connect(path?: string, options?: VoiceTurnQualityClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnQualityReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-workflow-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export declare class VoiceWorkflowStatusService {
+    connect(path?: string, options?: VoiceWorkflowStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+        report: import("@angular/core").Signal<VoiceScenarioEvalReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/appKit.d.ts

@@ -0,0 +1,100 @@
+import { Elysia } from 'elysia';
+import { type VoiceAssistantHealthRoutesOptions } from './assistantHealth';
+import { type VoiceBargeInRoutesOptions } from './bargeInRoutes';
+import { type VoiceDiagnosticsRoutesOptions } from './diagnosticsRoutes';
+import { type VoiceEvalRoutesOptions, type VoiceEvalLink } from './evalRoutes';
+import { type VoiceHandoffHealthRoutesOptions } from './handoffHealth';
+import { type VoiceOpsConsoleRoutesOptions } from './opsConsoleRoutes';
+import { type VoiceProviderHealthRoutesOptions } from './providerHealth';
+import { type VoiceProviderCapabilityRoutesOptions } from './providerCapabilities';
+import { type VoiceProductionReadinessRoutesOptions } from './productionReadiness';
+import { type VoiceQualityRoutesOptions } from './qualityRoutes';
+import { type VoiceResilienceRoutesOptions } from './resilienceRoutes';
+import { type VoiceSessionListRoutesOptions, type VoiceSessionReplayRoutesOptions } from './sessionReplay';
+import { type VoiceTraceEventStore } from './trace';
+import { type VoiceTraceTimelineRoutesOptions } from './traceTimeline';
+export type VoiceAppKitSurface = 'assistantHealth' | 'bargeIn' | 'diagnostics' | 'evals' | 'handoffs' | 'opsConsole' | 'providerCapabilities' | 'providerHealth' | 'productionReadiness' | 'quality' | 'resilience' | 'sessionReplay' | 'sessions' | 'traceTimeline';
+export type VoiceAppKitLink = VoiceEvalLink & {
+    description?: string;
+    statusHref?: string;
+};
+export type VoiceAppKitRoutesOptions<TProvider extends string = string> = {
+    appStatus?: false | VoiceAppKitStatusOptions;
+    assistantHealth?: false | Partial<VoiceAssistantHealthRoutesOptions<TProvider>>;
+    bargeIn?: false | Partial<VoiceBargeInRoutesOptions>;
+    diagnostics?: false | Partial<Omit<VoiceDiagnosticsRoutesOptions, 'store'>>;
+    evals?: false | Partial<VoiceEvalRoutesOptions>;
+    handoffs?: false | Partial<VoiceHandoffHealthRoutesOptions>;
+    headers?: HeadersInit;
+    links?: VoiceAppKitLink[];
+    llmProviders?: readonly TProvider[];
+    name?: string;
+    opsConsole?: false | Partial<VoiceOpsConsoleRoutesOptions>;
+    providerCapabilities?: false | Partial<VoiceProviderCapabilityRoutesOptions<TProvider>>;
+    providerHealth?: false | Partial<VoiceProviderHealthRoutesOptions<TProvider>>;
+    productionReadiness?: false | Partial<VoiceProductionReadinessRoutesOptions>;
+    quality?: false | Partial<VoiceQualityRoutesOptions>;
+    resilience?: false | Partial<VoiceResilienceRoutesOptions>;
+    sessionReplay?: false | Partial<VoiceSessionReplayRoutesOptions>;
+    sessions?: false | Partial<VoiceSessionListRoutesOptions>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    traceTimeline?: false | Partial<VoiceTraceTimelineRoutesOptions>;
+    ttsProviders?: readonly string[];
+};
+export type VoiceAppKitStatus = 'pass' | 'fail';
+export type VoiceAppKitStatusOptions = {
+    include?: {
+        handoffs?: boolean;
+        providers?: boolean;
+        quality?: boolean;
+        sessions?: boolean;
+        workflows?: boolean;
+    };
+    path?: string;
+    preferFixtureWorkflows?: boolean;
+};
+export type VoiceAppKitStatusReport = {
+    checkedAt: number;
+    failed: number;
+    links: VoiceAppKitLink[];
+    passed: number;
+    status: VoiceAppKitStatus;
+    surfaces: {
+        handoffs?: {
+            failed: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        providers?: {
+            degraded: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        quality?: {
+            status: VoiceAppKitStatus;
+        };
+        sessions?: {
+            failed: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        workflows?: {
+            failed: number;
+            source: 'fixtures' | 'live';
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+    };
+    total: number;
+};
+export type VoiceAppKitRoutes<TProvider extends string = string> = {
+    links: VoiceAppKitLink[];
+    routes: Elysia;
+    surfaces: VoiceAppKitSurface[];
+    use: Elysia['use'];
+};
+export declare const summarizeVoiceAppKitStatus: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => Promise<VoiceAppKitStatusReport>;
+export declare const createVoiceAppKitRoutes: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => VoiceAppKitRoutes<TProvider>;
+export declare const createVoiceAppKit: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => VoiceAppKitRoutes<TProvider>;

package/dist/assistantHealth.d.ts

@@ -0,0 +1,81 @@
+import { Elysia } from 'elysia';
+import { type VoiceAssistantRunsSummary } from './assistant';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceAssistantHealthFailure = {
+    at: number;
+    assistantId?: string;
+    error?: string;
+    provider?: string;
+    rateLimited?: boolean;
+    replayHref?: string;
+    sessionId: string;
+    status?: string;
+    turnId?: string;
+    type: StoredVoiceTraceEvent['type'];
+};
+export type VoiceAssistantHealthSummary<TProvider extends string = string> = {
+    assistantRuns: VoiceAssistantRunsSummary;
+    providerHealth: VoiceProviderHealthSummary<TProvider>[];
+    recentFailures: VoiceAssistantHealthFailure[];
+};
+export type VoiceAssistantHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    maxFailures?: number;
+    providers?: readonly TProvider[];
+    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, 'replayHref'>) => string);
+    store?: VoiceTraceEventStore;
+};
+export type VoiceAssistantHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceAssistantHealthSummaryOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceAssistantHealthSummary<TProvider>) => string | Promise<string>;
+};
+export type VoiceAssistantHealthRoutesOptions<TProvider extends string = string> = VoiceAssistantHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceAssistantHealth: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const renderVoiceAssistantHealthHTML: <TProvider extends string = string>(summary: VoiceAssistantHealthSummary<TProvider>) => string;
+export declare const createVoiceAssistantHealthJSONHandler: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => () => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const createVoiceAssistantHealthHTMLHandler: <TProvider extends string = string>(options: VoiceAssistantHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceAssistantHealthRoutes: <TProvider extends string = string>(options: VoiceAssistantHealthRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceAssistantHealthSummary<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/bargeInRoutes.d.ts

@@ -0,0 +1,56 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceBargeInMonitorSnapshot } from './types';
+export type VoiceBargeInRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: string;
+    name?: string;
+    path?: string;
+    store: VoiceTraceEventStore;
+    thresholdMs?: number;
+    title?: string;
+};
+export type VoiceBargeInReport = VoiceBargeInMonitorSnapshot & {
+    checkedAt: number;
+    sessions: Array<{
+        averageLatencyMs?: number;
+        failed: number;
+        passed: number;
+        sessionId: string;
+        total: number;
+    }>;
+};
+export declare const summarizeVoiceBargeIn: (events: StoredVoiceTraceEvent[], options?: {
+    thresholdMs?: number;
+}) => VoiceBargeInReport;
+export declare const renderVoiceBargeInHTML: (report: VoiceBargeInReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceBargeInRoutes: (options: VoiceBargeInRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;