@absolutejs/voice 0.0.22-beta.4 → 0.0.22-beta.400

package/dist/profileSwitchRecommendation.d.ts

@@ -0,0 +1,350 @@
+import { Elysia } from 'elysia';
+import type { VoiceRealCallProfileDefault, VoiceRealCallProfileDefaultsReport, VoiceRealCallProfileHistoryReport } from './proofTrends';
+import { type StoredVoiceAuditEvent, type VoiceAuditActor, type VoiceAuditEventStore } from './audit';
+import type { VoiceTraceEventStore } from './trace';
+export type VoiceProfileSwitchObservedSignals = {
+    currentProfileId?: string;
+    fallbackUsed?: boolean;
+    liveP95Ms?: number;
+    providerP95Ms?: number;
+    turnP95Ms?: number;
+    turnWarnings?: number;
+};
+export type VoiceProfileSwitchRecommendation = {
+    currentProfile?: {
+        label?: string;
+        profileId: string;
+        status: string;
+    };
+    generatedAt: string;
+    issues: string[];
+    nextMove: string;
+    ok: boolean;
+    observed: VoiceProfileSwitchObservedSignals;
+    reasons: string[];
+    recommendedProfile?: {
+        evidence: VoiceRealCallProfileDefault['evidence'];
+        label?: string;
+        latencyBudgets: VoiceRealCallProfileDefault['latencyBudgets'];
+        profileId: string;
+        providerRoutes: Record<string, string>;
+        status: string;
+    };
+    status: 'stay' | 'switch' | 'warn';
+};
+export type VoiceProfileSwitchRecommendationOptions = {
+    defaultProfileId?: string;
+    defaults: VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport;
+    minImprovementMs?: number;
+    observed?: VoiceProfileSwitchObservedSignals;
+};
+export type VoiceProfileSwitchGuardMode = 'auto' | 'off' | 'recommend';
+export type VoiceProfileSwitchGuardAction = 'blocked' | 'disabled' | 'recommend' | 'stay' | 'switch';
+export type VoiceProfileSwitchGuardDecision = {
+    action: VoiceProfileSwitchGuardAction;
+    auditEvent?: StoredVoiceAuditEvent;
+    autoApplied: boolean;
+    autoSwitchCount: number;
+    blockedByPolicy?: 'allowed-profiles' | 'blocked-profiles' | 'max-switches';
+    confidence: number;
+    minConfidence: number;
+    mode: VoiceProfileSwitchGuardMode;
+    maxAutoSwitchesPerSession: number;
+    previousProfileId?: string;
+    reason: string;
+    recommendation: VoiceProfileSwitchRecommendation;
+    recommendedProfileId?: string;
+    selectedProfileId?: string;
+};
+export type VoiceProfileSwitchGuardOptions = VoiceProfileSwitchRecommendationOptions & {
+    actor?: VoiceAuditActor;
+    allowedProfileIds?: string[];
+    audit?: VoiceAuditEventStore;
+    autoSwitchCount?: number;
+    blockedProfileIds?: string[];
+    maxAutoSwitchesPerSession?: number;
+    metadata?: Record<string, unknown>;
+    minConfidence?: number;
+    mode?: VoiceProfileSwitchGuardMode;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoiceProfileSwitchPolicyProofCase = {
+    description?: string;
+    expectedAction?: VoiceProfileSwitchGuardAction;
+    expectedBlockedByPolicy?: VoiceProfileSwitchGuardDecision['blockedByPolicy'];
+    id: string;
+    label?: string;
+    options?: Partial<Omit<VoiceProfileSwitchGuardOptions, 'defaults' | 'observed'>> & {
+        observed?: VoiceProfileSwitchObservedSignals;
+    };
+};
+export type VoiceProfileSwitchPolicyProofCaseResult = VoiceProfileSwitchPolicyProofCase & {
+    decision: VoiceProfileSwitchGuardDecision;
+    ok: boolean;
+};
+export type VoiceProfileSwitchPolicyProofReport = {
+    generatedAt: string;
+    ok: boolean;
+    observed: VoiceProfileSwitchObservedSignals;
+    results: VoiceProfileSwitchPolicyProofCaseResult[];
+    summary: {
+        failed: number;
+        passed: number;
+        total: number;
+    };
+};
+export type VoiceProfileSwitchPolicyProofOptions = {
+    actor?: VoiceAuditActor;
+    allowedProfileIds?: string[];
+    audit?: VoiceAuditEventStore;
+    cases?: VoiceProfileSwitchPolicyProofCase[];
+    defaults: VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport | (() => Promise<VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport> | VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport);
+    metadata?: Record<string, unknown>;
+    minConfidence?: number;
+    observed?: VoiceProfileSwitchObservedSignals;
+    title?: string;
+};
+export type VoiceProfileSwitchPolicyProofRoutesOptions = VoiceProfileSwitchPolicyProofOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchPolicyProofReport) => string | Promise<string>;
+};
+export type VoiceProfileSwitchLiveDecisionEvidence = {
+    action?: VoiceProfileSwitchGuardAction | string;
+    at: number;
+    auditEventId?: string;
+    autoApplied?: boolean;
+    autoSwitchCount?: number;
+    blockedByPolicy?: string;
+    confidence?: number;
+    maxAutoSwitchesPerSession?: number;
+    minConfidence?: number;
+    mode?: VoiceProfileSwitchGuardMode | string;
+    outcome?: string;
+    previousProfileId?: string;
+    reason?: string;
+    recommendedProfileId?: string;
+    scenarioId?: string;
+    selectedProfileId?: string;
+    sessionId: string;
+    source: 'audit' | 'trace';
+    status?: string;
+    traceEventId?: string;
+    traceId?: string;
+};
+export type VoiceProfileSwitchLiveDecisionSession = {
+    actionCounts: Record<string, number>;
+    actions: string[];
+    autoApplied: number;
+    blockedByPolicy: string[];
+    decisions: VoiceProfileSwitchLiveDecisionEvidence[];
+    firstSeenAt: number;
+    lastDecision?: VoiceProfileSwitchLiveDecisionEvidence;
+    lastSeenAt: number;
+    sessionId: string;
+};
+export type VoiceProfileSwitchLiveDecisionReport = {
+    generatedAt: string;
+    ok: boolean;
+    sessions: VoiceProfileSwitchLiveDecisionSession[];
+    summary: {
+        auditEvents: number;
+        autoApplied: number;
+        blocked: number;
+        decisions: number;
+        recommendations: number;
+        sessions: number;
+        switches: number;
+        traceEvents: number;
+    };
+};
+export type VoiceProfileSwitchLiveDecisionReportOptions = {
+    audit?: VoiceAuditEventStore;
+    limit?: number;
+    sessionId?: string;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceProfileSwitchLiveDecisionRoutesOptions = VoiceProfileSwitchLiveDecisionReportOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchLiveDecisionReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProfileSwitchReadinessStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProfileSwitchReadinessIssue = {
+    code: string;
+    message: string;
+    status: Exclude<VoiceProfileSwitchReadinessStatus, 'pass'>;
+};
+export type VoiceProfileSwitchReadinessReport = {
+    generatedAt: string;
+    issues: VoiceProfileSwitchReadinessIssue[];
+    live: VoiceProfileSwitchLiveDecisionReport;
+    policy?: VoiceProfileSwitchPolicyProofReport;
+    status: VoiceProfileSwitchReadinessStatus;
+    summary: {
+        auditEvents: number;
+        autoApplied: number;
+        blocked: number;
+        decisions: number;
+        policyCases?: number;
+        sessions: number;
+        switches: number;
+        traceEvents: number;
+    };
+};
+export type VoiceProfileSwitchReadinessOptions = VoiceProfileSwitchLiveDecisionReportOptions & {
+    autoMode?: boolean;
+    maxBlockedRatio?: number;
+    maxAutoAppliedRatio?: number;
+    policyProof?: false | VoiceProfileSwitchPolicyProofOptions;
+    requireAudit?: boolean;
+    requireAllowedProfilePolicy?: boolean;
+    requireLiveDecisions?: boolean;
+    requirePolicyProof?: boolean;
+    requireTrace?: boolean;
+};
+export type VoiceProfileSwitchReadinessRoutesOptions = VoiceProfileSwitchReadinessOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProfileSwitchReadinessReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const recommendVoiceProfileSwitch: (options: VoiceProfileSwitchRecommendationOptions) => VoiceProfileSwitchRecommendation;
+export declare const applyVoiceProfileSwitchGuard: (options: VoiceProfileSwitchGuardOptions) => Promise<VoiceProfileSwitchGuardDecision>;
+export declare const runVoiceProfileSwitchPolicyProof: (options: VoiceProfileSwitchPolicyProofOptions) => Promise<VoiceProfileSwitchPolicyProofReport>;
+export declare const renderVoiceProfileSwitchPolicyProofHTML: (report: VoiceProfileSwitchPolicyProofReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProfileSwitchPolicyProofRoutes: (options: VoiceProfileSwitchPolicyProofRoutesOptions) => 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: VoiceProfileSwitchPolicyProofReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const buildVoiceProfileSwitchLiveDecisionReport: (options: VoiceProfileSwitchLiveDecisionReportOptions) => Promise<VoiceProfileSwitchLiveDecisionReport>;
+export declare const renderVoiceProfileSwitchLiveDecisionHTML: (report: VoiceProfileSwitchLiveDecisionReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProfileSwitchLiveDecisionRoutes: (options: VoiceProfileSwitchLiveDecisionRoutesOptions) => 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: VoiceProfileSwitchLiveDecisionReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const buildVoiceProfileSwitchReadinessReport: (options: VoiceProfileSwitchReadinessOptions) => Promise<VoiceProfileSwitchReadinessReport>;
+export declare const renderVoiceProfileSwitchReadinessHTML: (report: VoiceProfileSwitchReadinessReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProfileSwitchReadinessRoutes: (options: VoiceProfileSwitchReadinessRoutesOptions) => 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: VoiceProfileSwitchReadinessReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/proofAssertions.d.ts

@@ -0,0 +1,32 @@
+export type VoiceProofAssertionResult = {
+    kind: 'json-assertion';
+    name: string;
+    ok: boolean;
+    summary?: Record<string, unknown>;
+};
+export type VoiceProofAssertionSummary = {
+    failed: number;
+    failures: Array<{
+        name: string;
+        summary?: Record<string, unknown>;
+    }>;
+    ok: boolean;
+    passed: number;
+    total: number;
+};
+export type VoiceProofAssertionInput = {
+    missingIssue?: string;
+    name: string;
+    ok?: boolean;
+    summary?: Record<string, unknown>;
+};
+export type VoiceEvidenceAssertionInput<TEvidence> = {
+    evidence?: TEvidence;
+    missingIssue?: string;
+    name: string;
+    ok?: (evidence: TEvidence) => boolean;
+    summary?: (evidence: TEvidence) => Record<string, unknown>;
+};
+export declare const createVoiceProofAssertion: (input: VoiceProofAssertionInput) => VoiceProofAssertionResult;
+export declare const createVoiceEvidenceAssertion: <TEvidence>(input: VoiceEvidenceAssertionInput<TEvidence>) => VoiceProofAssertionResult;
+export declare const summarizeVoiceProofAssertions: (assertions: VoiceProofAssertionResult[]) => VoiceProofAssertionSummary;

package/dist/proofRunner.d.ts

@@ -0,0 +1,79 @@
+export type VoiceProofTargetMethod = 'GET' | 'POST';
+export type VoiceProofTarget = {
+    accept?: string;
+    allowLogicalFail?: boolean;
+    body?: unknown;
+    kind: 'json' | 'text';
+    method?: VoiceProofTargetMethod;
+    name: string;
+    path: string;
+    requiredText?: string[];
+};
+export type VoiceProofTargetResult = {
+    body?: unknown;
+    bytes: number;
+    elapsedMs: number;
+    error?: string;
+    kind: VoiceProofTarget['kind'];
+    method: VoiceProofTargetMethod;
+    name: string;
+    ok: boolean;
+    path: string;
+    status?: number;
+    summary?: Record<string, unknown>;
+    url: string;
+};
+export type VoiceCommandProofTarget = {
+    command: string[];
+    kind: 'command';
+    name: string;
+};
+export type VoiceCommandProofExecutionResult = {
+    status: number;
+    stderr?: string;
+    stdout?: string;
+};
+export type VoiceCommandProofTargetResult = {
+    body?: unknown;
+    bytes: number;
+    command: string[];
+    elapsedMs: number;
+    error?: string;
+    kind: 'command';
+    name: string;
+    ok: boolean;
+    status?: number;
+    summary?: Record<string, unknown>;
+};
+export type VoiceProofTargetRunnerOptions = {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    now?: () => number;
+    timeoutMs?: number;
+    writeArtifact?: (input: {
+        content: string;
+        name: string;
+        target: VoiceProofTarget;
+    }) => Promise<void> | void;
+};
+export type VoiceProofTargetRunOptions = VoiceProofTargetRunnerOptions & {
+    concurrency?: number;
+};
+export type VoiceCommandProofTargetRunnerOptions = {
+    execute: (target: VoiceCommandProofTarget) => Promise<VoiceCommandProofExecutionResult> | VoiceCommandProofExecutionResult;
+    now?: () => number;
+    writeArtifact?: (input: {
+        content: string;
+        name: string;
+        target: VoiceCommandProofTarget;
+    }) => Promise<void> | void;
+};
+export type VoiceCommandProofTargetRunOptions = VoiceCommandProofTargetRunnerOptions & {
+    concurrency?: number;
+};
+export declare const getVoiceProofTargetLogicalFailure: (value: unknown) => "Response status is \"fail\"." | "Response pass is false." | "Response ok is false." | undefined;
+export declare const mapVoiceProofTargetsWithConcurrency: <TInput, TOutput>(items: TInput[], limit: number, mapper: (item: TInput) => Promise<TOutput>) => Promise<TOutput[]>;
+export declare const fetchVoiceProofTarget: (target: VoiceProofTarget, options: VoiceProofTargetRunnerOptions) => Promise<VoiceProofTargetResult>;
+export declare const runVoiceProofTargets: (targets: VoiceProofTarget[], options: VoiceProofTargetRunOptions) => Promise<VoiceProofTargetResult[]>;
+export declare const runVoiceCommandProofTarget: (target: VoiceCommandProofTarget, options: VoiceCommandProofTargetRunnerOptions) => Promise<VoiceCommandProofTargetResult>;
+export declare const runVoiceCommandProofTargets: (targets: VoiceCommandProofTarget[], options: VoiceCommandProofTargetRunOptions) => Promise<VoiceCommandProofTargetResult[]>;