@absolutejs/voice 0.0.22-beta.14 → 0.0.22-beta.140

package/dist/vue/useVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../campaignDialers';
+export declare function useVoiceCampaignDialerProof(path?: string, options?: VoiceCampaignDialerProofClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    report: import("vue").ShallowRef<VoiceCampaignDialerProofReport | undefined, VoiceCampaignDialerProofReport | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    status: import("vue").ShallowRef<VoiceCampaignDialerProofStatus | undefined, VoiceCampaignDialerProofStatus | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceController.d.ts

@@ -1,5 +1,5 @@
 import type { VoiceControllerOptions, VoiceTurnRecord } from '../types';
-export declare const useVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => {
+export declare function useVoiceController<TResult = unknown>(path: string, options?: VoiceControllerOptions): {
     assistantAudio: import("vue").ShallowRef<{
         chunk: Uint8Array;
         format: import("..").AudioFormat;
@@ -19,6 +19,7 @@ export declare const useVoiceController: <TResult = unknown>(path: string, optio
     isConnected: import("vue").Ref<boolean, boolean>;
     isRecording: import("vue").Ref<boolean, boolean>;
     partial: import("vue").Ref<string, string>;
+    reconnect: import("vue").ShallowRef<import("..").VoiceReconnectClientState, import("..").VoiceReconnectClientState>;
     recordingError: import("vue").Ref<string | null, string | null>;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     sessionId: import("vue").Ref<string | null, string | null>;

package/dist/vue/useVoiceOpsStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceOpsStatusClientOptions } from '../client/opsStatus';
+import type { VoiceOpsStatusReport } from '../opsStatus';
+export declare function useVoiceOpsStatus(path?: string, options?: VoiceOpsStatusClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+    report: import("vue").ShallowRef<VoiceOpsStatusReport | undefined, VoiceOpsStatusReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderCapabilities.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProviderCapabilitiesClientOptions } from '../client/providerCapabilities';
+import type { VoiceProviderCapabilityReport } from '../providerCapabilities';
+export declare function useVoiceProviderCapabilities<TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+    report: import("vue").ShallowRef<VoiceProviderCapabilityReport<TProvider> | undefined, VoiceProviderCapabilityReport<TProvider> | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderSimulationControls.d.ts

@@ -0,0 +1,24 @@
+import { type VoiceProviderSimulationControlsOptions } from '../client/providerSimulationControls';
+export declare function useVoiceProviderSimulationControls<TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>): {
+    error: import("vue").Ref<string | null, string | null>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    lastResult: import("vue").Ref<{
+        fallbackProvider?: import("vue").UnwrapRef<TProvider> | undefined;
+        mode: import("../testing").VoiceIOProviderFailureSimulationMode;
+        provider: import("vue").UnwrapRef<TProvider>;
+        sessionId: string;
+        status: "simulated";
+        suppressedUntil?: number | undefined;
+    } | null, import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | {
+        fallbackProvider?: import("vue").UnwrapRef<TProvider> | undefined;
+        mode: import("../testing").VoiceIOProviderFailureSimulationMode;
+        provider: import("vue").UnwrapRef<TProvider>;
+        sessionId: string;
+        status: "simulated";
+        suppressedUntil?: number | undefined;
+    } | null>;
+    mode: import("vue").Ref<import("../testing").VoiceIOProviderFailureSimulationMode | null, import("../testing").VoiceIOProviderFailureSimulationMode | null>;
+    provider: [TProvider | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & TProvider, import("vue").Ref<import("vue").Ref<any, any> & TProvider, import("vue").Ref<any, any> & TProvider>, import("vue").Ref<any, any> & TProvider> : import("vue").Ref<import("vue").UnwrapRef<TProvider> | null, TProvider | import("vue").UnwrapRef<TProvider> | null>;
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare function useVoiceProviderStatus<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    providers: import("vue").ShallowRef<VoiceProviderHealthSummary<TProvider>[], VoiceProviderHealthSummary<TProvider>[]>;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceRoutingStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceRoutingStatusClientOptions } from '../client/routingStatus';
+export declare function useVoiceRoutingStatus(path?: string, options?: VoiceRoutingStatusClientOptions): {
+    decision: import("vue").ShallowRef<import("..").VoiceRoutingEvent | null, import("..").VoiceRoutingEvent | null>;
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceStream.d.ts

@@ -1,5 +1,5 @@
 import type { VoiceConnectionOptions, VoiceTurnRecord } from '../types';
-export declare const useVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
+export declare function useVoiceStream<TResult = unknown>(path: string, options?: VoiceConnectionOptions): {
     assistantAudio: import("vue").ShallowRef<{
         chunk: Uint8Array;
         format: import("..").AudioFormat;
@@ -12,11 +12,14 @@ export declare const useVoiceStream: <TResult = unknown>(path: string, options?:
         turnId?: string;
     }[]>;
     assistantTexts: import("vue").ShallowRef<string[], string[]>;
+    call: import("vue").ShallowRef<import("..").VoiceCallLifecycleState | null, import("..").VoiceCallLifecycleState | null>;
+    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     error: import("vue").Ref<string | null, string | null>;
     isConnected: import("vue").Ref<boolean, boolean>;
     partial: import("vue").Ref<string, string>;
+    reconnect: import("vue").ShallowRef<import("..").VoiceReconnectClientState, import("..").VoiceReconnectClientState>;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     sessionId: import("vue").Ref<string | null, string | null>;
     status: import("vue").Ref<import("..").VoiceSessionStatus | "idle", import("..").VoiceSessionStatus | "idle">;

package/dist/vue/useVoiceTraceTimeline.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTraceTimelineClientOptions } from '../client/traceTimeline';
+import type { VoiceTraceTimelineReport } from '../traceTimeline';
+export declare function useVoiceTraceTimeline(path?: string, options?: VoiceTraceTimelineClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    report: import("vue").ShallowRef<VoiceTraceTimelineReport | null, VoiceTraceTimelineReport | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceTurnLatency.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceTurnLatencyClientOptions } from '../client/turnLatency';
+import type { VoiceTurnLatencyReport } from '../turnLatency';
+export declare function useVoiceTurnLatency(path?: string, options?: VoiceTurnLatencyClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+    report: import("vue").ShallowRef<VoiceTurnLatencyReport | undefined, VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceTurnQuality.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTurnQualityClientOptions } from '../client/turnQuality';
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export declare function useVoiceTurnQuality(path?: string, options?: VoiceTurnQualityClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+    report: import("vue").ShallowRef<VoiceTurnQualityReport | undefined, VoiceTurnQualityReport | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceWorkflowStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export declare function useVoiceWorkflowStatus(path?: string, options?: VoiceWorkflowStatusClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+    report: import("vue").ShallowRef<VoiceScenarioEvalReport | undefined, VoiceScenarioEvalReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/workflowContract.d.ts

@@ -0,0 +1,91 @@
+import type { VoiceScenarioEvalDefinition } from './evalRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceOnTurnHandler, VoiceRouteResult, VoiceSessionRecord, VoiceTurnRecord } from './types';
+export type VoiceWorkflowOutcome = 'complete' | 'transfer' | 'escalate' | 'voicemail' | 'no-answer';
+export type VoiceWorkflowContractFieldMatch = 'boolean' | 'non-empty' | 'number' | 'string' | 'truthy';
+export type VoiceWorkflowContractField = {
+    aliases?: string[];
+    label?: string;
+    match?: VoiceWorkflowContractFieldMatch;
+    path: string;
+    required?: boolean;
+};
+export type VoiceWorkflowContractDefinition<TResult = unknown> = {
+    description?: string;
+    fields?: VoiceWorkflowContractField[];
+    forbiddenHandoffActions?: string[];
+    id: string;
+    label?: string;
+    maxProviderErrors?: number;
+    maxSessionErrors?: number;
+    minSessions?: number;
+    minTurns?: number;
+    outcome?: VoiceWorkflowOutcome;
+    requiredAssistantIncludes?: string[];
+    requiredDisposition?: string;
+    requiredHandoffActions?: string[];
+    requiredLifecycleTypes?: string[];
+    requiredTranscriptIncludes?: string[];
+    scenarioId?: string;
+    validate?: (input: {
+        result: TResult | undefined;
+        routeResult: VoiceRouteResult<TResult>;
+    }) => VoiceWorkflowContractValidationIssue[];
+};
+export type VoiceWorkflowContractPresetName = 'appointment-booking' | 'lead-qualification' | 'support-triage' | 'transfer-handoff' | 'voicemail-callback';
+export type VoiceWorkflowContractPresetOptions<TResult = unknown> = Partial<Omit<VoiceWorkflowContractDefinition<TResult>, 'fields' | 'id'>> & {
+    fields?: VoiceWorkflowContractField[];
+    id?: string;
+};
+export type VoiceWorkflowContractValidationIssue = {
+    code: string;
+    field?: string;
+    message: string;
+};
+export type VoiceWorkflowContractValidation = {
+    contractId: string;
+    issues: VoiceWorkflowContractValidationIssue[];
+    missingFields: string[];
+    outcome?: VoiceWorkflowOutcome;
+    pass: boolean;
+    requiredFields: string[];
+};
+export type VoiceWorkflowContract<TResult = unknown> = {
+    assertRouteResult: (routeResult: VoiceRouteResult<TResult>) => void;
+    definition: VoiceWorkflowContractDefinition<TResult>;
+    toScenarioEval: (overrides?: Partial<VoiceScenarioEvalDefinition>) => VoiceScenarioEvalDefinition;
+    validateRouteResult: (routeResult: VoiceRouteResult<TResult>) => VoiceWorkflowContractValidation;
+};
+export type VoiceWorkflowContractTracePayload = {
+    contractId: string;
+    issues: VoiceWorkflowContractValidationIssue[];
+    missingFields: string[];
+    outcome?: VoiceWorkflowOutcome;
+    requiredFields: string[];
+    status: 'pass' | 'fail';
+};
+export declare const validateVoiceWorkflowRouteResult: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, routeResult: VoiceRouteResult<TResult>) => VoiceWorkflowContractValidation;
+export declare const createVoiceWorkflowScenario: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, overrides?: Partial<VoiceScenarioEvalDefinition>) => VoiceScenarioEvalDefinition;
+export declare const createVoiceWorkflowContract: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>) => VoiceWorkflowContract<TResult>;
+export declare const createVoiceWorkflowContractPreset: <TResult = unknown>(name: VoiceWorkflowContractPresetName, options?: VoiceWorkflowContractPresetOptions<TResult>) => VoiceWorkflowContract<TResult>;
+export declare const recordVoiceWorkflowContractTrace: (input: {
+    at?: number;
+    contractId?: string;
+    scenarioId?: string;
+    sessionId: string;
+    store: VoiceTraceEventStore;
+    traceId?: string;
+    turnId?: string;
+    validation: VoiceWorkflowContractValidation;
+}) => Promise<StoredVoiceTraceEvent<VoiceWorkflowContractTracePayload>>;
+export declare const createVoiceWorkflowContractHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(input: {
+    contract?: VoiceWorkflowContract<TResult> | VoiceWorkflowContractDefinition<TResult>;
+    handler: VoiceOnTurnHandler<TContext, TSession, TResult>;
+    resolveContract?: (args: {
+        context: TContext;
+        result: VoiceRouteResult<TResult>;
+        session: TSession;
+        turn: VoiceTurnRecord;
+    }) => VoiceWorkflowContract<TResult> | VoiceWorkflowContractDefinition<TResult> | undefined;
+    store?: VoiceTraceEventStore;
+}) => VoiceOnTurnHandler<TContext, TSession, TResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.14",
+	"version": "0.0.22-beta.140",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",