@absolutejs/voice 0.0.22-beta.7 → 0.0.22-beta.71

package/dist/vue/useVoiceAppKitStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceAppKitStatusClientOptions } from '../client/appKitStatus';
+import type { VoiceAppKitStatusReport } from '../appKit';
+export declare const useVoiceAppKitStatus: (path?: string, options?: VoiceAppKitStatusClientOptions) => {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceAppKitStatusReport | undefined>;
+    report: import("vue").ShallowRef<VoiceAppKitStatusReport | undefined, VoiceAppKitStatusReport | 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 const 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 const 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 const 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 const 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

@@ -12,6 +12,8 @@ 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>;

package/dist/vue/useVoiceTurnQuality.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTurnQualityClientOptions } from '../client/turnQuality';
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export declare const 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 const 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.7",
+	"version": "0.0.22-beta.71",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",