@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.531

package/dist/internal/evidence.d.ts

@@ -0,0 +1,10 @@
+export type VoiceEvidenceAssertion = {
+    ok: boolean;
+    issues: string[];
+};
+/**
+ * Throw if an evidence assertion failed, formatting its issues into the error
+ * message. Returns the assertion unchanged when it passed, so callers can
+ * `return assertVoiceEvidence(label, evaluate(...))`.
+ */
+export declare const assertVoiceEvidence: <A extends VoiceEvidenceAssertion>(failureMessage: string, assertion: A) => A;

package/dist/internal/html.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Escape a value for safe interpolation into HTML text/attributes. Accepts any
+ * value (non-strings are stringified) and escapes the five HTML-significant
+ * characters.
+ */
+export declare const escapeHtml: (value: unknown) => string;

package/dist/internal/status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The shared three-level health status used across voice reports. Severity
+ * order is fail > warn > pass.
+ */
+export type VoiceStatus = "fail" | "pass" | "warn";
+/** Severity rank for a status (fail=2, warn=1, pass=0). Higher is worse. */
+export declare const voiceStatusRank: (status: VoiceStatus) => number;
+/** Reduce a set of statuses to the worst one (fail > warn > pass). */
+export declare const worstVoiceStatus: (statuses: Iterable<VoiceStatus>) => VoiceStatus;

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/liveCoach.d.ts

@@ -0,0 +1,43 @@
+export type VoiceCoachNudgeKind = "hint" | "correction" | "warning" | "script-line" | "knowledge";
+export type VoiceCoachNudge = {
+    id: string;
+    sessionId: string;
+    supervisorId: string;
+    kind: VoiceCoachNudgeKind;
+    text: string;
+    createdAt: number;
+    injected: boolean;
+    injectedAt?: number;
+    acknowledged: boolean;
+    acknowledgedAt?: number;
+    expiresAt?: number;
+};
+export type VoiceCoachNudgeInjection = {
+    role: "system" | "developer";
+    content: string;
+    metadata: {
+        nudgeId: string;
+        supervisorId: string;
+        kind: VoiceCoachNudgeKind;
+    };
+};
+export type CreateVoiceLiveCoachOptions = {
+    sessionId: string;
+    injectionRole?: "system" | "developer";
+    templateForKind?: Partial<Record<VoiceCoachNudgeKind, string>>;
+    defaultExpiryMs?: number;
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare const createVoiceLiveCoach: (options: CreateVoiceLiveCoachOptions) => {
+    acknowledge: (id: string) => boolean;
+    consumeForInjection: () => VoiceCoachNudgeInjection[];
+    history: () => VoiceCoachNudge[];
+    pending: () => VoiceCoachNudge[];
+    push: (input: Omit<VoiceCoachNudge, "id" | "createdAt" | "injected" | "acknowledged" | "sessionId"> & {
+        id?: string;
+    }) => VoiceCoachNudge;
+    sessionId: string;
+    subscribe(listener: (nudge: VoiceCoachNudge) => void): () => void;
+};
+export type VoiceLiveCoach = ReturnType<typeof createVoiceLiveCoach>;

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/mcpToolset.d.ts

@@ -0,0 +1,58 @@
+import { type VoiceAgentTool } from "./agent";
+import type { VoiceSessionRecord } from "./types";
+/**
+ * Minimal structural shapes from the Model Context Protocol. Any MCP client
+ * (`@modelcontextprotocol/sdk` over stdio / SSE / streamable-HTTP, or a custom
+ * transport) that exposes `listTools` + `callTool` satisfies this — voice does
+ * not bundle an MCP SDK.
+ */
+export type MCPToolDefinition = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export type MCPToolContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type MCPToolCallResult = {
+    content?: MCPToolContentBlock[];
+    structuredContent?: unknown;
+    isError?: boolean;
+};
+export type MCPClientLike = {
+    listTools: () => Promise<{
+        tools: MCPToolDefinition[];
+    }> | {
+        tools: MCPToolDefinition[];
+    };
+    callTool: (input: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<MCPToolCallResult> | MCPToolCallResult;
+};
+export type VoiceMCPToolResult = {
+    text: string;
+    structuredContent?: unknown;
+    isError: boolean;
+    raw: MCPToolCallResult;
+};
+export type CreateVoiceMCPToolsetOptions = {
+    client: MCPClientLike;
+    /** Prefix applied to every exposed tool name (e.g. "mcp_"). */
+    namePrefix?: string;
+    /** Only expose tools whose (unprefixed) name is in this allow-list. */
+    allowedTools?: ReadonlyArray<string>;
+    /** Drop tools whose (unprefixed) name is in this block-list. */
+    blockedTools?: ReadonlyArray<string>;
+    /** Override how an MCP result is flattened to the assistant-visible string. */
+    resultToMessage?: (result: VoiceMCPToolResult) => string;
+};
+/**
+ * Bridges the tools exposed by an MCP server into `VoiceAgentTool`s. Call once
+ * at setup; the returned array spreads straight into `createVoiceAgent({ tools })`.
+ */
+export declare const createVoiceMCPToolset: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: CreateVoiceMCPToolsetOptions) => Promise<VoiceAgentTool<TContext, TSession, Record<string, unknown>, VoiceMCPToolResult>[]>;