@absolutejs/voice 0.0.21 → 0.0.22-beta.0

package/dist/ops.d.ts

@@ -0,0 +1,100 @@
+import type { VoiceCallDisposition, VoiceSessionRecord, VoiceSessionSummary } from './types';
+import type { StoredVoiceCallReviewArtifact } from './testing/review';
+export type VoiceOpsTaskStatus = 'open' | 'in-progress' | 'done';
+export type VoiceOpsTaskKind = 'callback' | 'escalation' | 'transfer-check' | 'retry-review';
+export type VoiceOpsTaskHistoryEntry = {
+    actor: string;
+    at: number;
+    detail?: string;
+    type: 'created' | 'assigned' | 'started' | 'completed' | 'reopened';
+};
+export type VoiceOpsTask = {
+    assignee?: string;
+    createdAt: number;
+    description: string;
+    history: VoiceOpsTaskHistoryEntry[];
+    id: string;
+    intakeId?: string;
+    kind: VoiceOpsTaskKind;
+    outcome?: VoiceCallDisposition;
+    recommendedAction: string;
+    reviewId?: string;
+    status: VoiceOpsTaskStatus;
+    target?: string;
+    title: string;
+    updatedAt: number;
+};
+export type StoredVoiceOpsTask = VoiceOpsTask;
+export type VoiceOpsTaskStore<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
+    get: (id: string) => Promise<TTask | undefined> | TTask | undefined;
+    list: () => Promise<TTask[]> | TTask[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, task: TTask) => Promise<void> | void;
+};
+export type VoiceOpsTaskSummary = {
+    byKind: Array<[VoiceOpsTaskKind, number]>;
+    byOutcome: Array<[string, number]>;
+    done: number;
+    inProgress: number;
+    open: number;
+    topAssignees: Array<[string, number]>;
+    topTargets: Array<[string, number]>;
+    total: number;
+};
+export type VoiceIntegrationEventType = 'call.completed' | 'review.saved' | 'task.created' | 'task.updated';
+export type VoiceIntegrationEvent = {
+    createdAt: number;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    deliveryError?: string;
+    id: string;
+    payload: Record<string, unknown>;
+    type: VoiceIntegrationEventType;
+};
+export type StoredVoiceIntegrationEvent = VoiceIntegrationEvent;
+export type VoiceIntegrationEventStore<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    get: (id: string) => Promise<TEvent | undefined> | TEvent | undefined;
+    list: () => Promise<TEvent[]> | TEvent[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, event: TEvent) => Promise<void> | void;
+};
+export declare const withVoiceOpsTaskId: <TTask extends Omit<VoiceOpsTask, "id"> = Omit<VoiceOpsTask, "id">>(id: string, task: TTask) => TTask & {
+    id: string;
+};
+export declare const withVoiceIntegrationEventId: <TEvent extends Omit<VoiceIntegrationEvent, "id"> = Omit<VoiceIntegrationEvent, "id">>(id: string, event: TEvent) => TEvent & {
+    id: string;
+};
+export declare const buildVoiceOpsTaskFromReview: (review: StoredVoiceCallReviewArtifact) => StoredVoiceOpsTask | null;
+export declare const assignVoiceOpsTask: (task: StoredVoiceOpsTask, owner: string, input?: {
+    at?: number;
+    actor?: string;
+}) => StoredVoiceOpsTask;
+export declare const startVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
+export declare const completeVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
+export declare const reopenVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
+export declare const listVoiceOpsTasks: (tasks: StoredVoiceOpsTask[]) => VoiceOpsTask[];
+export declare const summarizeVoiceOpsTasks: (tasks: StoredVoiceOpsTask[]) => VoiceOpsTaskSummary;
+export declare const createVoiceIntegrationEvent: <TPayload extends Record<string, unknown> = Record<string, unknown>>(type: VoiceIntegrationEventType, payload: TPayload, input?: {
+    createdAt?: number;
+    id?: string;
+}) => StoredVoiceIntegrationEvent;
+export declare const createVoiceCallCompletedEvent: (input: {
+    disposition?: VoiceCallDisposition;
+    session: VoiceSessionRecord;
+    sessionSummary?: VoiceSessionSummary;
+}) => StoredVoiceIntegrationEvent;
+export declare const createVoiceReviewSavedEvent: (review: StoredVoiceCallReviewArtifact) => StoredVoiceIntegrationEvent;
+export declare const createVoiceTaskCreatedEvent: (task: StoredVoiceOpsTask) => StoredVoiceIntegrationEvent;
+export declare const createVoiceTaskUpdatedEvent: (task: StoredVoiceOpsTask) => StoredVoiceIntegrationEvent;

package/dist/react/index.js

@@ -102,6 +102,14 @@ var normalizeErrorMessage = (value) => {
 };
 var serverMessageToAction = (message) => {
   switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
     case "assistant":
       return {
         text: message.text,
@@ -182,6 +190,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -354,6 +363,7 @@ var createVoiceConnection = (path, options = {}) => {
 
 // src/client/store.ts
 var createInitialState = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -371,6 +381,20 @@ var createVoiceStreamStore = () => {
   };
   const dispatch = (action) => {
     switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
       case "assistant":
         state = {
           ...state,
@@ -510,6 +534,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -524,6 +551,7 @@ var createVoiceStream = (path, options = {}) => {
 
 // src/react/useVoiceStream.tsx
 var EMPTY_SNAPSHOT = {
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -915,6 +943,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -958,6 +1038,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -986,6 +1067,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1113,12 +1195,16 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
     }
   };
 };
 
 // src/react/useVoiceController.tsx
 var EMPTY_SNAPSHOT2 = {
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,

package/dist/react/useVoiceController.d.ts

@@ -13,6 +13,12 @@ export declare const useVoiceController: <TResult = unknown>(path: string, optio
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
     error: string | null;
     isConnected: boolean;
     isRecording: boolean;

package/dist/react/useVoiceStream.d.ts

@@ -9,6 +9,12 @@ export declare const useVoiceStream: <TResult = unknown>(path: string, options?:
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
     error: string | null;
     isConnected: boolean;
 };

package/dist/routing.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from './types';
+export declare const resolveVoiceSTTRoutingStrategy: (goal?: VoiceSTTRoutingGoal) => VoiceSTTRoutingStrategy;
+export declare const createVoiceSTTRoutingCorrectionHandler: (mode?: VoiceSTTRoutingCorrectionMode) => VoiceTurnCorrectionHandler | undefined;

package/dist/runtimeOps.d.ts

@@ -0,0 +1,23 @@
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from './testing/review';
+import type { VoiceOpsTask } from './ops';
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export declare const createVoiceCallReviewFromSession: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(input: {
+    disposition: VoiceCallDisposition;
+    generatedAt?: number;
+    reason?: string;
+    session: TSession;
+    target?: string;
+}) => VoiceCallReviewArtifact;
+export declare const recordVoiceRuntimeOps: <TContext, TSession extends VoiceSessionRecord, TResult>(input: {
+    api: VoiceSessionHandle<TContext, TSession, TResult>;
+    config?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    context: TContext;
+    disposition: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    session: TSession;
+    target?: string;
+}) => Promise<{
+    review: StoredVoiceCallReviewArtifact | undefined;
+    task: VoiceOpsTask | undefined;
+} | undefined>;

package/dist/svelte/index.js

@@ -99,6 +99,14 @@ var normalizeErrorMessage = (value) => {
 };
 var serverMessageToAction = (message) => {
   switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
     case "assistant":
       return {
         text: message.text,
@@ -179,6 +187,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -351,6 +360,7 @@ var createVoiceConnection = (path, options = {}) => {
 
 // src/client/store.ts
 var createInitialState = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -368,6 +378,20 @@ var createVoiceStreamStore = () => {
   };
   const dispatch = (action) => {
     switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
       case "assistant":
         state = {
           ...state,
@@ -507,6 +531,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -886,6 +913,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -929,6 +1008,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -957,6 +1037,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1084,6 +1165,9 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
     }
   };
 };

package/dist/telephony/response.d.ts

@@ -0,0 +1,7 @@
+export type TelephonyResponseShapeMode = 'full' | 'lead-clause';
+export type TelephonyResponseShapeOptions = {
+    mode?: TelephonyResponseShapeMode;
+    maxChars?: number;
+    maxWords?: number;
+};
+export declare const shapeTelephonyAssistantText: (text: string, options?: TelephonyResponseShapeOptions) => string;

package/dist/telephony/twilio.d.ts

@@ -0,0 +1,116 @@
+import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from '../testing/review';
+import type { AudioFormat, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
+type TwilioMediaPayload = {
+    chunk?: string;
+    payload: string;
+    timestamp?: string;
+    track?: 'inbound' | 'outbound';
+};
+type TwilioConnectedMessage = {
+    event: 'connected';
+    protocol?: string;
+    version?: string;
+};
+type TwilioStartMessage = {
+    event: 'start';
+    sequenceNumber?: string;
+    start: {
+        accountSid?: string;
+        callSid?: string;
+        customParameters?: Record<string, string>;
+        mediaFormat?: {
+            channels?: number;
+            encoding?: string;
+            sampleRate?: number;
+        };
+        streamSid: string;
+        track?: string;
+    };
+    streamSid?: string;
+};
+type TwilioMediaMessage = {
+    event: 'media';
+    media: TwilioMediaPayload;
+    sequenceNumber?: string;
+    streamSid: string;
+};
+type TwilioMarkMessage = {
+    event: 'mark';
+    mark?: {
+        name?: string;
+    };
+    sequenceNumber?: string;
+    streamSid: string;
+};
+type TwilioStopMessage = {
+    event: 'stop';
+    sequenceNumber?: string;
+    stop?: {
+        accountSid?: string;
+        callSid?: string;
+    };
+    streamSid: string;
+};
+export type TwilioInboundMessage = TwilioConnectedMessage | TwilioStartMessage | TwilioMediaMessage | TwilioMarkMessage | TwilioStopMessage;
+export type TwilioOutboundMediaMessage = {
+    event: 'media';
+    media: {
+        payload: string;
+    };
+    streamSid: string;
+};
+export type TwilioOutboundClearMessage = {
+    event: 'clear';
+    streamSid: string;
+};
+export type TwilioOutboundMarkMessage = {
+    event: 'mark';
+    mark: {
+        name: string;
+    };
+    streamSid: string;
+};
+export type TwilioOutboundMessage = TwilioOutboundMediaMessage | TwilioOutboundClearMessage | TwilioOutboundMarkMessage;
+export type TwilioMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoicePluginConfig<TContext, TSession, TResult>, 'htmx' | 'path'> & {
+    clearOnInboundMedia?: boolean;
+    context: TContext;
+    logger?: VoiceLogger;
+    onVoiceMessage?: (input: {
+        callSid?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamSid?: string;
+    }) => Promise<void> | void;
+    review?: {
+        config?: VoiceCallReviewConfig;
+        fixtureId?: string;
+        onArtifact?: (artifact: VoiceCallReviewArtifact) => Promise<void> | void;
+        path?: string;
+        title?: string;
+    };
+    scenarioId?: string;
+    sessionId?: string;
+};
+export type TwilioMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamSid: () => string | null;
+    handleMessage: (raw: string | TwilioInboundMessage) => Promise<void>;
+};
+export type TwilioVoiceResponseOptions = {
+    parameters?: Record<string, string | number | boolean | undefined>;
+    streamName?: string;
+    streamUrl: string;
+    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+};
+export declare const decodeTwilioMulawBase64: (payload: string) => Int16Array<ArrayBuffer>;
+export declare const encodeTwilioMulawBase64: (samples: Int16Array) => string;
+export declare const transcodeTwilioInboundPayloadToPCM16: (payload: string) => Uint8Array<ArrayBuffer>;
+export declare const transcodePCMToTwilioOutboundPayload: (chunk: Uint8Array, format: AudioFormat) => string;
+export declare const createTwilioVoiceResponse: (options: TwilioVoiceResponseOptions) => string;
+export declare const createTwilioMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TwilioMediaStreamSocket, options: TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>) => TwilioMediaStreamBridge;
+export {};

package/dist/testing/benchmark.d.ts

@@ -1,4 +1,4 @@
-import type { STTAdapter } from '../types';
+import type { STTAdapter, STTAdapterOpenOptions } from '../types';
 import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult } from './stt';
 import type { VoiceTestFixture } from './fixtures';
 export type VoiceExpectedTermAccuracy = {
@@ -8,7 +8,15 @@ export type VoiceExpectedTermAccuracy = {
     missingTerms: string[];
     recall: number;
 };
-export type VoiceSTTFixtureEnvironment = 'accent' | 'accent-noisy' | 'clean' | 'noisy' | 'other';
+export type VoiceSTTFixtureEnvironment = 'accent' | 'accent-noisy' | 'clean' | 'code-switch' | 'jargon' | 'multilingual' | 'multi-speaker' | 'noisy' | 'telephony' | 'other';
+export type VoiceSpeakerTurnAccuracy = {
+    available: boolean;
+    actualTurnCount: number;
+    expectedTurnCount: number;
+    passes: boolean;
+    patternMatchRate: number;
+    postClustered?: boolean;
+};
 export type VoiceSTTBenchmarkFixtureResult = {
     accuracy: VoiceSTTAdapterHarnessResult['accuracy'];
     closeCount: number;
@@ -24,6 +32,7 @@ export type VoiceSTTBenchmarkFixtureResult = {
     group: VoiceSTTFixtureEnvironment;
     passes: boolean;
     partialCount: number;
+    speakerTurns?: VoiceSpeakerTurnAccuracy;
     postSpeechTimeToEndOfTurnMs?: number;
     postSpeechTimeToFirstFinalMs?: number;
     tags: string[];
@@ -38,6 +47,7 @@ export type VoiceSTTBenchmarkSummary = {
     averageElapsedMs: number;
     averageEndOfTurnCount: number;
     averageFinalCount: number;
+    averageSpeakerTurnMatchRate?: number;
     averageTermRecall: number;
     averagePostSpeechTimeToEndOfTurnMs?: number;
     averagePostSpeechTimeToFirstFinalMs?: number;
@@ -63,6 +73,7 @@ export type VoiceSTTBenchmarkFixtureSummary = {
     passRate: number;
     wordAccuracyRate: number;
     averageTermRecall: number;
+    averageSpeakerTurnMatchRate?: number;
     averageWordErrorRate: number;
     averageElapsedMs: number;
 };
@@ -72,6 +83,38 @@ export type VoiceSTTBenchmarkReport = {
     generatedAt: number;
     summary: VoiceSTTBenchmarkSummary;
 };
+export type VoiceSTTBenchmarkFixtureAggregate = {
+    averageElapsedMs: number;
+    averagePassRate: number;
+    averageWordErrorRate: number;
+    bestWordErrorRate: number;
+    fixtureId: string;
+    group: VoiceSTTFixtureEnvironment;
+    passCount: number;
+    runCount: number;
+    tags: string[];
+    title: string;
+    worstWordErrorRate: number;
+};
+export type VoiceSTTBenchmarkSeriesSummary = {
+    adapterId: string;
+    averageElapsedMs: number;
+    averagePassRate: number;
+    averageWordErrorRate: number;
+    fixtureCount: number;
+    flakyFixtureCount: number;
+    generatedRunCount: number;
+    stableFixtureCount: number;
+    totalPassCount: number;
+    totalRunCount: number;
+};
+export type VoiceSTTBenchmarkSeriesReport = {
+    adapterId: string;
+    fixtures: VoiceSTTBenchmarkFixtureAggregate[];
+    generatedAt: number;
+    runCount: number;
+    summary: VoiceSTTBenchmarkSeriesSummary;
+};
 export type VoiceSTTBenchmarkComparisonEntry = {
     adapterId: string;
     summary: VoiceSTTBenchmarkSummary;
@@ -98,9 +141,10 @@ export type VoiceSTTBenchmarkAcceptanceResult = {
     score: number;
 };
 export type VoiceSTTBenchmarkOptions = VoiceSTTAdapterHarnessOptions & {
-    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, 'fixtureOptions'>>;
+    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, 'fixtureOptions' | 'openOptions'>>;
+    openOptions?: Partial<STTAdapterOpenOptions> | ((fixture: VoiceTestFixture) => Partial<STTAdapterOpenOptions> | undefined);
 };
-export declare const resolveFixtureEnvironment: (fixture: Pick<VoiceTestFixture, "tags">) => VoiceSTTFixtureEnvironment;
+export declare const resolveFixtureEnvironment: (fixture: Pick<VoiceTestFixture, "language" | "tags">) => VoiceSTTFixtureEnvironment;
 export declare const summarizeSTTBenchmark: (adapterId: string, fixtures: VoiceSTTBenchmarkFixtureResult[]) => VoiceSTTBenchmarkSummary;
 export declare const evaluateSTTBenchmarkAcceptance: (report: VoiceSTTBenchmarkReport, thresholds?: VoiceSTTBenchmarkAcceptanceThresholds) => VoiceSTTBenchmarkAcceptanceResult;
 export declare const compareSTTBenchmarks: (reports: VoiceSTTBenchmarkReport[]) => VoiceSTTBenchmarkComparison;
@@ -110,3 +154,14 @@ export declare const runSTTAdapterBenchmark: ({ adapter, adapterId, fixtures, op
     fixtures: VoiceTestFixture[];
     options?: VoiceSTTBenchmarkOptions;
 }) => Promise<VoiceSTTBenchmarkReport>;
+export declare const summarizeSTTBenchmarkSeries: (input: {
+    adapterId: string;
+    reports: VoiceSTTBenchmarkReport[];
+}) => VoiceSTTBenchmarkSeriesReport;
+export declare const runSTTAdapterBenchmarkSeries: ({ adapter, adapterId, fixtures, options, runs }: {
+    adapter: STTAdapter;
+    adapterId: string;
+    fixtures: VoiceTestFixture[];
+    options?: VoiceSTTBenchmarkOptions;
+    runs: number;
+}) => Promise<VoiceSTTBenchmarkSeriesReport>;