@absolutejs/voice 0.0.22-beta.34 → 0.0.22-beta.36

package/dist/testing/index.d.ts

@@ -3,6 +3,7 @@ export * from './benchmark';
 export * from './corrected';
 export * from './duplex';
 export * from './fixtures';
+export * from './ioProviderSimulator';
 export * from './providerSimulator';
 export * from './resilience';
 export * from './review';

package/dist/testing/index.js

@@ -3510,6 +3510,123 @@ var loadVoiceTestFixtures = async (fixtureDirectory) => {
   }
   return fixtures;
 };
+// src/testing/ioProviderSimulator.ts
+var defaultFailureMessage = (input) => `Simulated ${input.provider} ${input.kind.toUpperCase()} ${input.operation} failure.`;
+var resolveRecoveryElapsedMs = (value, provider) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  return value?.[provider] ?? 25;
+};
+var createHealth = (input) => ({
+  consecutiveFailures: input.status === "healthy" ? 0 : 1,
+  lastFailureAt: input.status === "healthy" ? undefined : input.now,
+  provider: input.provider,
+  status: input.status,
+  suppressedUntil: input.suppressedUntil
+});
+var resolveFallback = async (options, provider) => {
+  const configured = typeof options.fallback === "function" ? await options.fallback(provider) : options.fallback;
+  return (configured ?? options.providers).find((candidate) => candidate !== provider);
+};
+var createVoiceIOProviderFailureSimulator = (options) => {
+  if (options.providers.length === 0) {
+    throw new Error("At least one provider is required.");
+  }
+  const now = options.now ?? Date.now;
+  const operation = options.operation ?? "open";
+  const cooldownMs = Math.max(0, options.cooldownMs ?? 30000);
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  const run = async (provider, mode) => {
+    if (!options.providers.includes(provider)) {
+      throw new Error(`${provider} is not configured for simulation.`);
+    }
+    const startedAt = now();
+    const sessionId = options.sessionId?.({ mode, now: startedAt, provider }) ?? `${options.kind}-provider-sim-${startedAt}`;
+    if (mode === "recovery") {
+      await emit({
+        at: startedAt,
+        attempt: 0,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, provider),
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[provider],
+        operation,
+        provider,
+        providerHealth: createHealth({
+          now: startedAt,
+          provider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "success"
+      }, { mode, provider, sessionId });
+      return {
+        mode,
+        provider,
+        sessionId,
+        status: "simulated"
+      };
+    }
+    const fallbackProvider = await resolveFallback(options, provider);
+    const suppressedUntil = startedAt + cooldownMs;
+    await emit({
+      at: startedAt,
+      attempt: 0,
+      elapsedMs: options.failureElapsedMs ?? 10,
+      error: (options.failureMessage ?? defaultFailureMessage)({
+        kind: options.kind,
+        operation,
+        provider
+      }),
+      fallbackProvider,
+      kind: options.kind,
+      latencyBudgetMs: options.latencyBudgets?.[provider],
+      operation,
+      provider,
+      providerHealth: createHealth({
+        now: startedAt,
+        provider,
+        status: "suppressed",
+        suppressedUntil
+      }),
+      selectedProvider: provider,
+      status: "error",
+      suppressedUntil
+    }, { mode, provider, sessionId });
+    if (fallbackProvider) {
+      await emit({
+        at: startedAt + 1,
+        attempt: 1,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, fallbackProvider),
+        fallbackProvider,
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[fallbackProvider],
+        operation,
+        provider: fallbackProvider,
+        providerHealth: createHealth({
+          now: startedAt + 1,
+          provider: fallbackProvider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "fallback"
+      }, { mode, provider, sessionId });
+    }
+    return {
+      fallbackProvider,
+      mode,
+      provider,
+      sessionId,
+      status: "simulated",
+      suppressedUntil
+    };
+  };
+  return {
+    run
+  };
+};
 // src/modelAdapters.ts
 var OUTPUT_SCHEMA = {
   additionalProperties: false,
@@ -8551,6 +8668,7 @@ export {
   getDefaultTTSBenchmarkFixtures,
   evaluateSTTBenchmarkAcceptance,
   createVoiceProviderFailureSimulator,
+  createVoiceIOProviderFailureSimulator,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromLiveTelephonyReport,
   createTelephonyVoiceTestFixtures,

package/dist/testing/ioProviderSimulator.d.ts

@@ -0,0 +1,41 @@
+import type { VoiceIOProviderRouterEvent } from '../providerAdapters';
+export type VoiceIOProviderFailureSimulationMode = 'failure' | 'recovery';
+export type VoiceIOProviderFailureSimulationKind = 'stt' | 'tts';
+export type VoiceIOProviderFailureSimulationOperation = 'open' | 'send';
+export type VoiceIOProviderFailureSimulationResult<TProvider extends string = string> = {
+    fallbackProvider?: TProvider;
+    mode: VoiceIOProviderFailureSimulationMode;
+    provider: TProvider;
+    sessionId: string;
+    status: 'simulated';
+    suppressedUntil?: number;
+};
+export type VoiceIOProviderFailureSimulatorOptions<TProvider extends string = string> = {
+    cooldownMs?: number;
+    fallback?: readonly TProvider[] | ((provider: TProvider) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    failureElapsedMs?: number;
+    failureMessage?: (input: {
+        kind: VoiceIOProviderFailureSimulationKind;
+        operation: VoiceIOProviderFailureSimulationOperation;
+        provider: TProvider;
+    }) => string;
+    kind: VoiceIOProviderFailureSimulationKind;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    now?: () => number;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>, input: {
+        mode: VoiceIOProviderFailureSimulationMode;
+        provider: TProvider;
+        sessionId: string;
+    }) => Promise<void> | void;
+    operation?: VoiceIOProviderFailureSimulationOperation;
+    providers: readonly TProvider[];
+    recoveryElapsedMs?: number | Partial<Record<TProvider, number>>;
+    sessionId?: (input: {
+        mode: VoiceIOProviderFailureSimulationMode;
+        now: number;
+        provider: TProvider;
+    }) => string;
+};
+export declare const createVoiceIOProviderFailureSimulator: <TProvider extends string>(options: VoiceIOProviderFailureSimulatorOptions<TProvider>) => {
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider>>;
+};

package/package.json

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