@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.510

package/dist/ivrPlan.d.ts

@@ -0,0 +1,40 @@
+export type VoiceIVRMatch = {
+    digit?: string;
+    digits?: string;
+    speech?: string | RegExp;
+};
+export type VoiceIVRBranch = {
+    assistantId?: string;
+    description?: string;
+    id: string;
+    label: string;
+    match: VoiceIVRMatch;
+    metadata?: Record<string, unknown>;
+    target?: string;
+};
+export type VoiceIVRPlan = {
+    branches: readonly VoiceIVRBranch[];
+    fallbackBranchId?: string;
+    greeting: string;
+    maxAttempts?: number;
+    noMatchPrompt?: string;
+    timeoutMs?: number;
+    timeoutPrompt?: string;
+};
+export type VoiceIVRInput = {
+    digits?: string;
+    speech?: string;
+};
+export type VoiceIVRDecision = {
+    branch?: VoiceIVRBranch;
+    reason: "matched" | "no-match" | "fallback" | "timeout";
+};
+export declare const evaluateVoiceIVRPlan: (plan: VoiceIVRPlan, input: VoiceIVRInput) => VoiceIVRDecision;
+export type VoiceIVRSession = {
+    attempt: () => number;
+    decide: (input: VoiceIVRInput) => VoiceIVRDecision;
+    exhausted: () => boolean;
+    reset: () => void;
+};
+export declare const createVoiceIVRSession: (plan: VoiceIVRPlan) => VoiceIVRSession;
+export declare const describeVoiceIVRPlan: (plan: VoiceIVRPlan) => string;

package/dist/latencySlo.d.ts

@@ -0,0 +1,56 @@
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceLatencySLOStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceLatencySLOStage = "assistant_text_to_tts_send" | "barge_in_stop" | "commit_to_assistant_text" | "final_to_commit" | "live_latency" | "provider_llm" | "provider_stt" | "provider_tts" | "speech_to_commit" | "tts_send_duration" | "tts_to_first_audio";
+export type VoiceLatencySLOBudget = {
+    failAfterMs: number;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOMeasurement = {
+    at: number;
+    latencyMs: number;
+    label: string;
+    provider?: string;
+    sessionId: string;
+    stage: VoiceLatencySLOStage;
+    status: Exclude<VoiceLatencySLOStatus, "empty">;
+    turnId?: string;
+};
+export type VoiceLatencySLOStageSummary = {
+    averageMs?: number;
+    budget: VoiceLatencySLOBudget;
+    failed: number;
+    label: string;
+    maxMs?: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    p50Ms?: number;
+    p95Ms?: number;
+    stage: VoiceLatencySLOStage;
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateReport = {
+    checkedAt: number;
+    failed: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    stages: VoiceLatencySLOStageSummary[];
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateOptions = {
+    budgets?: Partial<Record<VoiceLatencySLOStage, VoiceLatencySLOBudget>>;
+    events?: StoredVoiceTraceEvent[];
+    failAfterMs?: number;
+    limit?: number;
+    store?: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOGateError = Error & {
+    report: VoiceLatencySLOGateReport;
+};
+export declare const buildVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const assertVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const renderVoiceLatencySLOMarkdown: (report: VoiceLatencySLOGateReport, options?: {
+    title?: string;
+}) => string;

package/dist/liveLatency.d.ts

@@ -0,0 +1,78 @@
+import { Elysia } from "elysia";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceLiveLatencyStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceLiveLatencySample = {
+    at: number;
+    latencyMs: number;
+    sessionId: string;
+    status?: string;
+    traceId?: string;
+};
+export type VoiceLiveLatencyReport = {
+    averageLatencyMs?: number;
+    checkedAt: number;
+    failed: number;
+    p50LatencyMs?: number;
+    p95LatencyMs?: number;
+    recent: VoiceLiveLatencySample[];
+    status: VoiceLiveLatencyStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLiveLatencyOptions = {
+    failAfterMs?: number;
+    limit?: number;
+    store: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLiveLatencyRoutesOptions = VoiceLiveLatencyOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    title?: string;
+};
+export declare const summarizeVoiceLiveLatency: (options: VoiceLiveLatencyOptions) => Promise<VoiceLiveLatencyReport>;
+export declare const renderVoiceLiveLatencyHTML: (report: VoiceLiveLatencyReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceLiveLatencyRoutes: (options: VoiceLiveLatencyRoutesOptions) => 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: VoiceLiveLatencyReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/liveOps.d.ts

@@ -0,0 +1,190 @@
+import { Elysia } from "elysia";
+import { type VoiceAuditEventStore } from "./audit";
+import { type VoiceTraceEventStore } from "./trace";
+import type { VoiceOperationsRecord } from "./operationsRecord";
+import type { VoiceOpsActionHistoryReport } from "./opsActionAuditRoutes";
+import type { VoiceOpsRecoveryReport, VoiceOpsRecoveryStatus } from "./opsRecovery";
+import type { VoiceOpsStatusReport } from "./opsStatus";
+export declare const VOICE_LIVE_OPS_ACTIONS: readonly ["assign", "create-task", "escalate", "force-handoff", "inject-instruction", "operator-takeover", "pause-assistant", "resume-assistant", "tag"];
+export type VoiceLiveOpsAction = (typeof VOICE_LIVE_OPS_ACTIONS)[number];
+export type VoiceLiveOpsControlStatus = "assistant-paused" | "assistant-resumed" | "handoff-forced" | "instruction-injected" | "operator-takeover" | "recorded";
+export type VoiceLiveOpsControlState = {
+    assistantPaused: boolean;
+    handoffTarget?: string;
+    injectedInstruction?: string;
+    lastAction: VoiceLiveOpsAction;
+    lastUpdatedAt: number;
+    operator?: string;
+    operatorTakeover: boolean;
+    status: VoiceLiveOpsControlStatus;
+    tag?: string;
+};
+export type VoiceLiveOpsActionInput = {
+    action: VoiceLiveOpsAction;
+    assignee?: string;
+    detail?: string;
+    sessionId: string;
+    tag?: string;
+};
+export type VoiceLiveOpsActionResult = {
+    action: VoiceLiveOpsAction;
+    control: VoiceLiveOpsControlState;
+    ok: true;
+    sessionId: string;
+};
+export type VoiceLiveOpsEvidenceInput = {
+    actionHistory?: VoiceOpsActionHistoryReport;
+    maxActionHistoryFailures?: number;
+    maxOpsRecoveryIssues?: number;
+    minActionHistoryEntries?: number;
+    minInterventions?: number;
+    minOperationsRecordHandoffs?: number;
+    minOperationsRecordTasks?: number;
+    operationsRecord?: VoiceOperationsRecord;
+    opsRecovery?: VoiceOpsRecoveryReport;
+    opsStatus?: VoiceOpsStatusReport;
+    requireActionHistory?: boolean;
+    requireOperationsRecord?: boolean;
+    requireOperationsRecordAudit?: boolean;
+    requireOperationsRecordHealthy?: boolean;
+    requireOpsRecovery?: boolean;
+    requireOpsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    requireOpsStatus?: boolean;
+    requireOpsStatusPass?: boolean;
+    requiredHistoryActions?: string[];
+    requiredInterventionActions?: string[];
+};
+export type VoiceLiveOpsEvidenceReport = {
+    actionHistoryFailed?: number;
+    actionHistoryTotal?: number;
+    historyActions: string[];
+    interventionActions: string[];
+    interventions?: number;
+    issues: string[];
+    ok: boolean;
+    operationsRecordHandoffs?: number;
+    operationsRecordStatus?: VoiceOperationsRecord["status"];
+    operationsRecordTasks?: number;
+    opsRecoveryIssues?: number;
+    opsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    opsStatus?: VoiceOpsStatusReport["status"];
+};
+export type VoiceLiveOpsControlEvidenceInput = {
+    finalControl?: VoiceLiveOpsControlState | null;
+    maxFailedActions?: number;
+    minSnapshots?: number;
+    requireFinalAssistantPaused?: boolean;
+    requireFinalOperatorTakeover?: boolean;
+    requiredActions?: VoiceLiveOpsAction[];
+    requiredStatuses?: VoiceLiveOpsControlStatus[];
+    results?: Array<(Partial<Omit<VoiceLiveOpsActionResult, "ok">> & {
+        ok?: boolean;
+    }) | null | undefined>;
+};
+export type VoiceLiveOpsControlEvidenceReport = {
+    actionCount: number;
+    actions: VoiceLiveOpsAction[];
+    failedActions: number;
+    finalControl?: VoiceLiveOpsControlState;
+    finalStatus?: VoiceLiveOpsControlStatus;
+    issues: string[];
+    ok: boolean;
+    snapshots: number;
+    statuses: VoiceLiveOpsControlStatus[];
+};
+export type VoiceLiveOpsControlStore = {
+    get: (sessionId: string) => Promise<VoiceLiveOpsControlState | undefined> | VoiceLiveOpsControlState | undefined;
+    set: (sessionId: string, state: VoiceLiveOpsControlState) => Promise<void> | void;
+};
+export type VoiceLiveOpsControllerOptions = {
+    audit?: VoiceAuditEventStore;
+    defaultAssignee?: string;
+    defaultDetail?: string;
+    defaultTag?: string;
+    onAction?: (result: VoiceLiveOpsActionResult & {
+        assignee: string;
+        detail: string;
+        tag: string;
+    }) => Promise<void> | void;
+    store?: VoiceLiveOpsControlStore;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceLiveOpsRoutesOptions = VoiceLiveOpsControllerOptions & {
+    controlPath?: string;
+    name?: string;
+    path?: string;
+};
+export declare const evaluateVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
+export declare const assertVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
+export declare const evaluateVoiceLiveOpsControlEvidence: (input?: VoiceLiveOpsControlEvidenceInput) => VoiceLiveOpsControlEvidenceReport;
+export declare const assertVoiceLiveOpsControlEvidence: (input?: VoiceLiveOpsControlEvidenceInput) => VoiceLiveOpsControlEvidenceReport;
+export declare const createVoiceMemoryLiveOpsControlStore: () => VoiceLiveOpsControlStore;
+export declare const getVoiceLiveOpsControlStatus: (action: VoiceLiveOpsAction) => VoiceLiveOpsControlStatus;
+export declare const buildVoiceLiveOpsControlState: (input: VoiceLiveOpsActionInput & {
+    at?: number;
+    previous?: VoiceLiveOpsControlState;
+}) => VoiceLiveOpsControlState;
+export declare const createVoiceLiveOpsController: (options?: VoiceLiveOpsControllerOptions) => {
+    get: (sessionId: string) => VoiceLiveOpsControlState | Promise<VoiceLiveOpsControlState | undefined> | undefined;
+    perform: (input: VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult>;
+    store: VoiceLiveOpsControlStore;
+};
+export declare const createVoiceLiveOpsRoutes: (options?: VoiceLiveOpsRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceLiveOpsActionResult | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    control: VoiceLiveOpsControlState | undefined;
+                    ok: boolean;
+                    sessionId: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/llmJudge.d.ts

@@ -0,0 +1,45 @@
+import type { AIProviderConfig } from "@absolutejs/ai";
+export type VoiceLLMJudgeRubricCriterion = {
+    description: string;
+    id: string;
+    required?: boolean;
+    weight?: number;
+};
+export type VoiceLLMJudgeRubric = {
+    criteria: VoiceLLMJudgeRubricCriterion[];
+    minPassScore?: number;
+};
+export type VoiceLLMJudgeCriterionVerdict = {
+    criterionId: string;
+    passed: boolean;
+    rationale: string;
+};
+export type VoiceLLMJudgeVerdict = {
+    criteria: VoiceLLMJudgeCriterionVerdict[];
+    passed: boolean;
+    score: number;
+    summary?: string;
+};
+export type VoiceLLMJudgeInput = {
+    metadata?: Record<string, unknown>;
+    transcript: string;
+};
+export type VoiceLLMJudgeCompletion = (input: {
+    prompt: string;
+    systemPrompt?: string;
+}) => Promise<string>;
+export type CreateVoiceLLMJudgeOptions = {
+    completion: VoiceLLMJudgeCompletion;
+    rubric: VoiceLLMJudgeRubric;
+    systemPrompt?: string;
+};
+export type VoiceLLMJudge = {
+    evaluate: (input: VoiceLLMJudgeInput) => Promise<VoiceLLMJudgeVerdict>;
+    rubric: VoiceLLMJudgeRubric;
+};
+export declare const createVoiceLLMJudge: (options: CreateVoiceLLMJudgeOptions) => VoiceLLMJudge;
+export type CreateVoiceAIJudgeCompletionOptions = {
+    model: string;
+    provider: AIProviderConfig;
+};
+export declare const createVoiceAIJudgeCompletion: (options: CreateVoiceAIJudgeCompletionOptions) => VoiceLLMJudgeCompletion;

package/dist/logger.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceLogger } from './types';
+import type { VoiceLogger } from "./types";
 export declare const createNoopLogger: () => Required<VoiceLogger>;
 export declare const resolveLogger: (logger?: VoiceLogger) => {
     debug: (message: string, meta?: Record<string, unknown>) => void;

package/dist/mediaPipelineRoutes.d.ts

@@ -0,0 +1,171 @@
+import { Elysia } from "elysia";
+import { type MediaFrame, type MediaInterruptionReport, type MediaPipelineCalibrationIssue, type MediaPipelineCalibrationInput, type MediaPipelineCalibrationReport, type MediaPipelineStatus, type MediaProcessorGraphReport, type MediaProcessorGraphSummary, type MediaQualityReport, type MediaQualitySummary, type MediaResamplingPlan, type MediaTransportReport, type MediaTransportSummary, type MediaVadReport } from "@absolutejs/media";
+export type VoiceMediaPipelineReportOptions = MediaPipelineCalibrationInput & {
+    frames?: readonly MediaFrame[];
+    maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
+    maxSilenceFrames?: number;
+    minMediaSpeechRatio?: number;
+    minSpeechFrames?: number;
+    processorGraph?: MediaProcessorGraphReport;
+    speechEndThreshold?: number;
+    speechStartThreshold?: number;
+    transport?: MediaTransportReport;
+};
+export type VoiceMediaPipelineReport = {
+    calibration: MediaPipelineCalibrationReport;
+    checkedAt: number;
+    frames: number;
+    interruption: MediaInterruptionReport;
+    ok: boolean;
+    quality: MediaQualityReport;
+    resampling?: MediaResamplingPlan;
+    processorGraph?: MediaProcessorGraphReport;
+    sessionIds: string[];
+    status: MediaPipelineStatus;
+    surface: string;
+    transport?: MediaTransportReport;
+    vad: MediaVadReport;
+};
+export type VoiceMediaPipelineAssertionInput = {
+    maxFirstAudioLatencyMs?: number;
+    maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
+    minAssistantAudioFrames?: number;
+    minInputAudioFrames?: number;
+    minMediaSpeechRatio?: number;
+    minProcessorGraphEmittedFrames?: number;
+    minProcessorGraphNodes?: number;
+    minTransportInputFrames?: number;
+    minTransportOutputFrames?: number;
+    minTraceLinkedFrames?: number;
+    minVadSegments?: number;
+    maxTransportBackpressureEvents?: number;
+    requireInterruptionFrame?: boolean;
+    requirePass?: boolean;
+    requireProcessorGraph?: boolean;
+    requireQualityPass?: boolean;
+    requireResamplingReady?: boolean;
+    requireTransportConnected?: boolean;
+};
+export type VoiceMediaPipelineAssertionReport = {
+    issues: string[];
+    ok: boolean;
+    status: MediaPipelineStatus;
+    surface: string;
+};
+export type VoiceMediaPipelineRoutesOptions = VoiceMediaPipelineReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceMediaPipelineReport) => Promise<string> | string;
+    source?: (() => Promise<VoiceMediaPipelineReportOptions> | VoiceMediaPipelineReportOptions) | VoiceMediaPipelineReportOptions;
+    title?: string;
+};
+export declare const buildVoiceMediaPipelineReport: (options?: VoiceMediaPipelineReportOptions) => VoiceMediaPipelineReport;
+export declare const evaluateVoiceMediaPipelineEvidence: (report: VoiceMediaPipelineReport, input?: VoiceMediaPipelineAssertionInput) => VoiceMediaPipelineAssertionReport;
+export declare const assertVoiceMediaPipelineEvidence: (report: VoiceMediaPipelineReport, input?: VoiceMediaPipelineAssertionInput) => VoiceMediaPipelineAssertionReport;
+export declare const renderVoiceMediaPipelineMarkdown: (report: VoiceMediaPipelineReport) => string;
+export declare const renderVoiceMediaPipelineHTML: (report: VoiceMediaPipelineReport, title?: string) => string;
+export declare const createVoiceMediaPipelineRoutes: (options?: VoiceMediaPipelineRoutesOptions) => 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: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceMediaPipelineCalibrationSummary = {
+    assistantAudioFrames: number;
+    backpressureFrames: number;
+    firstAudioLatencyMs?: number;
+    inputAudioFrames: number;
+    interruptionFrames: number;
+    issueCodes: readonly string[];
+    jitterMs?: number;
+    resamplingRequired: boolean;
+    status: MediaPipelineStatus;
+    surface: string;
+    traceLinkedFrames: number;
+    turnCommitFrames: number;
+};
+export type VoiceMediaPipelineProofArtifactLinks = {
+    processorGraph?: string;
+    quality?: string;
+    transport?: string;
+};
+export type VoiceMediaPipelineProofSummary = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+    calibration: VoiceMediaPipelineCalibrationSummary;
+    checkedAt: number;
+    frames: number;
+    interruption: {
+        interruptionFrames: number;
+        issueCodes: readonly string[];
+        latenciesMs: readonly number[];
+        status: MediaPipelineStatus;
+    };
+    issueCodes: readonly string[];
+    issues: readonly MediaPipelineCalibrationIssue[];
+    ok: boolean;
+    processorGraph?: MediaProcessorGraphSummary;
+    quality: MediaQualitySummary;
+    resampling?: {
+        ratio: number;
+        required: boolean;
+        status: MediaPipelineStatus;
+    };
+    sessionIds: readonly string[];
+    status: MediaPipelineStatus;
+    surface: string;
+    transport?: MediaTransportSummary;
+    vad: {
+        inputAudioFrames: number;
+        segmentCount: number;
+        status: MediaPipelineStatus;
+    };
+};
+export type VoiceMediaPipelineProofSummaryOptions = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+};
+export declare const summarizeVoiceMediaPipelineReport: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineProofSummaryOptions) => VoiceMediaPipelineProofSummary;

package/dist/mediaPipelineSurfaces.d.ts

@@ -0,0 +1,48 @@
+import { type MediaProcessorGraphSummary, type MediaQualitySummary, type MediaTransportSummary } from "@absolutejs/media";
+import type { VoiceIncidentTimelineEvent } from "./incidentTimeline";
+import type { VoiceMediaPipelineReport } from "./mediaPipelineRoutes";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+export type VoiceMediaPipelineIssueSource = "calibration" | "interruption" | "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineIssueEntry = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    source: VoiceMediaPipelineIssueSource;
+    surface: string;
+};
+export declare const extractVoiceMediaPipelineIssueEntries: (report: VoiceMediaPipelineReport) => readonly VoiceMediaPipelineIssueEntry[];
+export type VoiceMediaPipelineReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export declare const buildVoiceMediaPipelineReadinessChecks: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineReadinessOptions) => readonly VoiceProductionReadinessCheck[];
+export type VoiceMediaPipelineIncidentOptions = {
+    baseHref?: string;
+    category?: VoiceIncidentTimelineEvent["category"];
+    now?: () => number;
+    source?: string;
+};
+export declare const buildVoiceMediaPipelineIncidentEvents: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineIncidentOptions) => readonly VoiceIncidentTimelineEvent[];
+export type VoiceMediaPipelineArtifactKind = "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineArtifactRecord = {
+    href?: string;
+    jsonPath: string;
+    kind: VoiceMediaPipelineArtifactKind;
+    markdownPath: string;
+    summary: MediaProcessorGraphSummary | MediaQualitySummary | MediaTransportSummary;
+};
+export type VoiceMediaPipelineArtifactWriteOptions = {
+    dir: string;
+    hrefBase?: string;
+    report: VoiceMediaPipelineReport;
+    slugPrefix?: string;
+};
+export type VoiceMediaPipelineArtifactWriteResult = {
+    artifacts: VoiceMediaPipelineArtifactRecord[];
+    hrefs: {
+        processorGraph?: string;
+        quality?: string;
+        transport?: string;
+    };
+};
+export declare const writeVoiceMediaPipelineArtifacts: (options: VoiceMediaPipelineArtifactWriteOptions) => Promise<VoiceMediaPipelineArtifactWriteResult>;

package/dist/memoryStore.d.ts

@@ -1,2 +1,2 @@
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
 export declare const createVoiceMemoryStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>() => VoiceSessionStore<TSession>;

package/dist/midCallSummary.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceLLMJudgeCompletion } from "./llmJudge";
+export type MidCallSummary = {
+    generatedAt: number;
+    summary: string;
+    topicalShift?: boolean;
+    turnCount: number;
+};
+export type CreateMidCallSummarizerOptions = {
+    completion: VoiceLLMJudgeCompletion;
+    /** Force a summary every N turns. Default 6. */
+    everyTurns?: number;
+    /** Force a summary at most every M ms. Default 60_000. */
+    minIntervalMs?: number;
+    /** Maximum chars to include in the system prompt. Default 600. */
+    summaryMaxChars?: number;
+    systemPrompt?: string;
+};
+export type MidCallSummarizer = {
+    evaluate: (input: {
+        session: VoiceSessionRecord;
+        turn?: VoiceTurnRecord;
+    }) => Promise<MidCallSummary | undefined>;
+    latest: () => MidCallSummary | undefined;
+};
+export declare const createMidCallSummarizer: (options: CreateMidCallSummarizerOptions) => MidCallSummarizer;
+export declare const extractTranscriptText: (transcripts: Transcript[]) => string;