@absolutejs/voice 0.0.22-beta.48 → 0.0.22-beta.481

package/dist/monitor.d.ts

@@ -0,0 +1,148 @@
+import { Elysia } from "elysia";
+import type { AudioFormat, VoiceMonitorRuntimeBinding, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+export type VoiceMonitorAudioSource = "assistant" | "caller" | (string & {});
+export type VoiceMonitorAudioEvent = {
+    at: number;
+    chunk: Uint8Array;
+    format: AudioFormat;
+    source: VoiceMonitorAudioSource;
+};
+export type VoiceMonitorSessionRecord = {
+    handle: VoiceSessionHandle<unknown, VoiceSessionRecord, unknown>;
+    metadata?: Record<string, unknown>;
+    onAudio: (handler: (event: VoiceMonitorAudioEvent) => void) => () => void;
+    onClose: (handler: (reason?: string) => void) => () => void;
+    sessionId: string;
+};
+export type VoiceMonitorRegistry = {
+    get: (sessionId: string) => VoiceMonitorSessionRecord | undefined;
+    list: () => readonly {
+        sessionId: string;
+    }[];
+};
+export type VoiceMonitorMutableRegistry = VoiceMonitorRegistry & {
+    emit: (sessionId: string, event: VoiceMonitorAudioEvent) => void;
+    emitClose: (sessionId: string, reason?: string) => void;
+    /**
+     * Deregister a session by id. No-op if the id isn't registered. The
+     * `reason` flows into the close fan-out exactly once.
+     */
+    deregister: (sessionId: string, reason?: string) => void;
+    register: (record: VoiceMonitorSessionRecord) => (reason?: string) => void;
+};
+export type VoiceMonitorRegistryRegisterInput = {
+    handle: VoiceSessionHandle<unknown, VoiceSessionRecord, unknown>;
+    metadata?: Record<string, unknown>;
+    sessionId: string;
+};
+export declare const createVoiceMonitorSession: (input: VoiceMonitorRegistryRegisterInput) => VoiceMonitorSessionRecord & {
+    emit: (event: VoiceMonitorAudioEvent) => void;
+    emitClose: (reason?: string) => void;
+};
+export declare const createVoiceInMemoryMonitorRegistry: () => VoiceMonitorMutableRegistry;
+export type VoiceMonitorControlMessage = {
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    target: string;
+    type: "transfer";
+} | {
+    reason?: string;
+    type: "hangup";
+} | {
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    type: "escalate";
+} | {
+    metadata?: Record<string, unknown>;
+    type: "voicemail";
+} | {
+    metadata?: Record<string, unknown>;
+    type: "no-answer";
+} | {
+    muted: boolean;
+    target: "assistant" | "caller";
+    type: "mute";
+} | {
+    interrupt?: boolean;
+    text: string;
+    type: "say";
+} | {
+    role: "assistant" | "system" | "user";
+    text: string;
+    type: "inject";
+};
+export type VoiceMonitorControlAck = {
+    detail?: string;
+    ok: true;
+    type: VoiceMonitorControlMessage["type"];
+} | {
+    error: string;
+    ok: false;
+    type: VoiceMonitorControlMessage["type"];
+};
+export type VoiceMonitorControlHandlerInput = {
+    message: VoiceMonitorControlMessage;
+    raw: unknown;
+    session: VoiceMonitorSessionRecord;
+};
+export type VoiceMonitorControlHandler = (input: VoiceMonitorControlHandlerInput) => Promise<VoiceMonitorControlAck> | VoiceMonitorControlAck;
+export type VoiceMonitorAuthenticateInput = {
+    request: unknown;
+    route: "control" | "listen";
+    sessionId: string;
+};
+export type VoiceMonitorAuthenticate = (input: VoiceMonitorAuthenticateInput) => boolean | Promise<boolean>;
+export type VoiceLiveMonitorRoutesOptions = {
+    authenticate?: VoiceMonitorAuthenticate;
+    basePath?: string;
+    controlHandlers?: Partial<Record<VoiceMonitorControlMessage["type"], VoiceMonitorControlHandler>>;
+    controlPath?: false | string;
+    htmlPath?: false | string;
+    listenPath?: false | string;
+    registry: VoiceMonitorRegistry;
+};
+export type VoiceMonitorPlanInput = {
+    basePath?: string;
+    baseUrl: string;
+    controlPath?: string;
+    listenPath?: string;
+    sessionId: string;
+};
+export type VoiceMonitorPlan = {
+    controlUrl: string;
+    listenUrl: string;
+};
+export declare const buildVoiceMonitorPlan: (input: VoiceMonitorPlanInput) => VoiceMonitorPlan;
+export type VoiceMonitorRuntimeBindingOptions = {
+    audioFormat?: AudioFormat;
+    defaultSource?: VoiceMonitorAudioSource;
+};
+export declare const createVoiceMonitorRuntimeBinding: (registry: VoiceMonitorMutableRegistry, options?: VoiceMonitorRuntimeBindingOptions) => VoiceMonitorRuntimeBinding;
+export declare const createVoiceLiveMonitorRoutes: (options: VoiceLiveMonitorRoutesOptions) => 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/multilingualProof.d.ts

@@ -0,0 +1,77 @@
+import type { STTAdapter } from "./types";
+import { type VoiceTestFixture } from "./testing/fixtures";
+import { type VoiceSTTBenchmarkOptions, type VoiceSTTBenchmarkReport } from "./testing/benchmark";
+export type VoiceMultilingualLanguageCode = string;
+export type VoiceMultilingualProofLanguageThresholds = {
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    maxAverageWordErrorRate?: number;
+    minAverageWordAccuracyRate?: number;
+    minPassRate?: number;
+    minTermRecall?: number;
+};
+export type VoiceMultilingualProofDefaultThresholds = Omit<VoiceMultilingualProofLanguageThresholds, "label" | "language">;
+export type VoiceMultilingualProofAdapterEntry = {
+    adapter: STTAdapter;
+    adapterId: string;
+    benchmarkOptions?: VoiceSTTBenchmarkOptions;
+};
+export type VoiceMultilingualProofOptions = {
+    adapters: readonly VoiceMultilingualProofAdapterEntry[];
+    defaultThresholds?: VoiceMultilingualProofDefaultThresholds;
+    filter?: (fixture: VoiceTestFixture) => boolean;
+    fixtureDirectories?: string | readonly string[];
+    fixtures?: readonly VoiceTestFixture[];
+    perLanguage?: readonly VoiceMultilingualProofLanguageThresholds[];
+};
+export type VoiceMultilingualProofLanguageMetrics = {
+    averageTermRecall: number;
+    averageWordAccuracyRate: number;
+    averageWordErrorRate: number;
+    fixtureCount: number;
+    passCount: number;
+    passRate: number;
+};
+export type VoiceMultilingualProofLanguageReport = {
+    applied: VoiceMultilingualProofLanguageThresholds;
+    failures: readonly string[];
+    fixtureIds: readonly string[];
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    metrics: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofAdapterReport = {
+    adapterId: string;
+    benchmark: VoiceSTTBenchmarkReport;
+    failures: readonly string[];
+    fixtureCount: number;
+    languageReports: readonly VoiceMultilingualProofLanguageReport[];
+    overall: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofReport = {
+    adapters: readonly VoiceMultilingualProofAdapterReport[];
+    generatedAt: number;
+    passes: boolean;
+    summary: {
+        adapterCount: number;
+        failedAdapters: readonly string[];
+        fixtureCount: number;
+        languageCount: number;
+    };
+};
+export declare const runVoiceMultilingualProof: (options: VoiceMultilingualProofOptions) => Promise<VoiceMultilingualProofReport>;
+export declare const renderVoiceMultilingualProofMarkdown: (report: VoiceMultilingualProofReport) => string;
+export type VoiceMultilingualProofReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export type VoiceMultilingualProofReadinessCheck = {
+    detail: string;
+    href?: string;
+    label: string;
+    status: "fail" | "pass" | "warn";
+    value?: number | string;
+};
+export declare const buildVoiceMultilingualProofReadinessCheck: (report: VoiceMultilingualProofReport, options?: VoiceMultilingualProofReadinessOptions) => VoiceMultilingualProofReadinessCheck;