@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/{assistant.d.ts → core/assistant.d.ts}

@@ -1,8 +1,8 @@
-import { type VoiceAgent, type VoiceAgentModel, type VoiceAgentOptions, type VoiceAgentSquadOptions, type VoiceAgentTool } from './agent';
-import { type VoiceOutcomeRecipeName, type VoiceOutcomeRecipeOptions } from './outcomeRecipes';
-import { type VoiceAssistantMemoryHandle, type VoiceAssistantMemoryOptions } from './assistantMemory';
-import type { VoiceNormalizedRouteConfig, VoiceOnTurnObjectHandler, VoiceRouteConfig, VoiceRouteResult, VoiceRuntimeOpsConfig, VoiceSessionRecord } from './types';
-import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import { type VoiceAgent, type VoiceAgentModel, type VoiceAgentOptions, type VoiceAgentSquadOptions, type VoiceAgentTool } from "./agent";
+import { type VoiceOutcomeRecipeName, type VoiceOutcomeRecipeOptions } from "./outcomeRecipes";
+import { type VoiceAssistantMemoryHandle, type VoiceAssistantMemoryOptions } from "./assistantMemory";
+import type { VoiceNormalizedRouteConfig, VoiceOnTurnObjectHandler, VoiceRouteConfig, VoiceRouteResult, VoiceRuntimeOpsConfig, VoiceSessionRecord } from "./types";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
 export type VoiceAssistantPreset = VoiceOutcomeRecipeName;
 export type VoiceAssistantArtifactPlan<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
@@ -27,7 +27,7 @@ export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSess
     maxToolRounds?: number;
     metadata?: Record<string, unknown>;
     model?: VoiceAgentModel<TContext, TSession, TResult>;
-    system?: VoiceAgentOptions<TContext, TSession, TResult>['system'];
+    system?: VoiceAgentOptions<TContext, TSession, TResult>["system"];
     tools?: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
     weight?: number;
 };
@@ -41,7 +41,7 @@ export type VoiceAssistantMemoryLifecycle<TContext = unknown, TSession extends V
     }) => Promise<void> | void;
     beforeTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult>) => Promise<void> | void;
 };
-export type VoiceAssistantExperimentResolverInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+type VoiceAssistantExperimentResolverInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
     assistantId: string;
     context: TContext;
     session: TSession;
@@ -59,7 +59,7 @@ export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends
     }) => VoiceAssistantVariant<TContext, TSession, TResult> | string | void;
     variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
 };
-type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
+export type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
     agent: VoiceAgent<TContext, TSession, TResult>;
     agents?: never;
     defaultAgentId?: never;
@@ -76,7 +76,7 @@ type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TR
     maxHandoffsPerTurn?: number;
     maxToolRounds?: never;
     model?: never;
-    selectAgent?: VoiceAgentSquadOptions<TContext, TSession, TResult>['selectAgent'];
+    selectAgent?: VoiceAgentSquadOptions<TContext, TSession, TResult>["selectAgent"];
     system?: never;
     tools?: never;
 } | {
@@ -87,7 +87,7 @@ type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TR
     maxToolRounds?: number;
     model: VoiceAgentModel<TContext, TSession, TResult>;
     selectAgent?: never;
-    system?: VoiceAgentOptions<TContext, TSession, TResult>['system'];
+    system?: VoiceAgentOptions<TContext, TSession, TResult>["system"];
     tools?: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
 };
 export type VoiceAssistantOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceAssistantAgentSource<TContext, TSession, TResult> & {
@@ -98,15 +98,15 @@ export type VoiceAssistantOptions<TContext = unknown, TSession extends VoiceSess
     memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
     memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
-    trace?: VoiceAgentOptions<TContext, TSession, TResult>['trace'];
+    trace?: VoiceAgentOptions<TContext, TSession, TResult>["trace"];
 };
 export type VoiceAssistant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     agent: VoiceAgent<TContext, TSession, TResult>;
     id: string;
     onTurn: VoiceOnTurnObjectHandler<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
-    route: (overrides: Omit<VoiceRouteConfig<TContext, TSession, TResult>, 'onComplete' | 'onTurn'> & {
-        onComplete?: VoiceRouteConfig<TContext, TSession, TResult>['onComplete'];
+    route: (overrides: Omit<VoiceRouteConfig<TContext, TSession, TResult>, "onComplete" | "onTurn"> & {
+        onComplete?: VoiceRouteConfig<TContext, TSession, TResult>["onComplete"];
     }) => VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
 };
 export type VoiceAssistantRunSummary = {
@@ -134,8 +134,8 @@ export type VoiceAssistantRunsSummary = {
     assistants: VoiceAssistantRunSummary[];
     totalRuns: number;
 };
-export declare const createVoiceExperiment: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantExperimentOptions<TContext, TSession, TResult>) => VoiceAssistantExperiment<TContext, TSession, TResult>;
 export declare const createVoiceAssistant: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantOptions<TContext, TSession, TResult>) => VoiceAssistant<TContext, TSession, TResult>;
+export declare const createVoiceExperiment: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantExperimentOptions<TContext, TSession, TResult>) => VoiceAssistantExperiment<TContext, TSession, TResult>;
 export declare const summarizeVoiceAssistantRuns: (input: StoredVoiceTraceEvent[] | {
     events?: StoredVoiceTraceEvent[];
     store?: VoiceTraceEventStore;

package/dist/core/assistantExperiment.d.ts

@@ -0,0 +1,42 @@
+import type { DefinedVoiceAssistant } from "./defineVoiceAssistant";
+import type { VoiceSessionRecord } from "./types";
+type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    /** Stable variant id used for trace tagging + rollups. */
+    id: string;
+    /** Relative weight when allocator is 'random' or 'sticky' bucketing. Default 1. */
+    weight?: number;
+    /** The assistant definition produced by defineVoiceAssistant. */
+    assistant: DefinedVoiceAssistant<TContext, TSession, TResult>;
+};
+type VoiceAssistantAllocatorInput<TContext = unknown> = {
+    context: TContext;
+    sessionId: string;
+    stickyKey?: string;
+};
+type VoiceAssistantAllocator<TContext = unknown> = (input: VoiceAssistantAllocatorInput<TContext>) => string;
+export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    /** Variant chooser. Default 'sticky' (hash of stickyKey → variant) when stickyKey is present, otherwise 'random'. */
+    allocator?: "random" | "sticky" | VoiceAssistantAllocator<TContext>;
+    /** Stable id for this experiment. Used in trace tagging. */
+    experimentId: string;
+    /** Callback for every allocation decision. Wire to trace.append({ type: 'assistant.experiment' }) for rollups. */
+    onAllocation?: (input: {
+        context: TContext;
+        experimentId: string;
+        sessionId: string;
+        stickyKey?: string;
+        variant: VoiceAssistantVariant<TContext, TSession, TResult>;
+    }) => void;
+    variants: ReadonlyArray<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+type VoiceAssistantExperimentDecision<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    experimentId: string;
+    variant: VoiceAssistantVariant<TContext, TSession, TResult>;
+};
+export type VoiceAssistantExperiment<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    allocate: (input: VoiceAssistantAllocatorInput<TContext>) => VoiceAssistantExperimentDecision<TContext, TSession, TResult>;
+    experimentId: string;
+    variants: ReadonlyArray<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+export declare const createVoiceAssistantExperiment: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantExperimentOptions<TContext, TSession, TResult>) => VoiceAssistantExperiment<TContext, TSession, TResult>;
+export {};

package/dist/{assistantHealth.d.ts → core/assistantHealth.d.ts}

@@ -1,7 +1,7 @@
-import { Elysia } from 'elysia';
-import { type VoiceAssistantRunsSummary } from './assistant';
-import { type VoiceProviderHealthSummary } from './providerHealth';
-import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import { Elysia } from "elysia";
+import { type VoiceAssistantRunsSummary } from "./assistant";
+import { type VoiceProviderHealthSummary } from "./providerHealth";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
 export type VoiceAssistantHealthFailure = {
     at: number;
     assistantId?: string;
@@ -12,7 +12,7 @@ export type VoiceAssistantHealthFailure = {
     sessionId: string;
     status?: string;
     turnId?: string;
-    type: StoredVoiceTraceEvent['type'];
+    type: StoredVoiceTraceEvent["type"];
 };
 export type VoiceAssistantHealthSummary<TProvider extends string = string> = {
     assistantRuns: VoiceAssistantRunsSummary;
@@ -23,7 +23,7 @@ export type VoiceAssistantHealthSummaryOptions<TProvider extends string = string
     events?: StoredVoiceTraceEvent[];
     maxFailures?: number;
     providers?: readonly TProvider[];
-    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, 'replayHref'>) => string);
+    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, "replayHref">) => string);
     store?: VoiceTraceEventStore;
 };
 export type VoiceAssistantHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceAssistantHealthSummaryOptions<TProvider> & {
@@ -35,10 +35,8 @@ export type VoiceAssistantHealthRoutesOptions<TProvider extends string = string>
     name?: string;
     path?: string;
 };
-export declare const summarizeVoiceAssistantHealth: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => Promise<VoiceAssistantHealthSummary<TProvider>>;
-export declare const renderVoiceAssistantHealthHTML: <TProvider extends string = string>(summary: VoiceAssistantHealthSummary<TProvider>) => string;
-export declare const createVoiceAssistantHealthJSONHandler: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => () => Promise<VoiceAssistantHealthSummary<TProvider>>;
 export declare const createVoiceAssistantHealthHTMLHandler: <TProvider extends string = string>(options: VoiceAssistantHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceAssistantHealthJSONHandler: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => () => Promise<VoiceAssistantHealthSummary<TProvider>>;
 export declare const createVoiceAssistantHealthRoutes: <TProvider extends string = string>(options: VoiceAssistantHealthRoutesOptions<TProvider>) => Elysia<"", {
     decorator: {};
     store: {};
@@ -79,3 +77,5 @@ export declare const createVoiceAssistantHealthRoutes: <TProvider extends string
     standaloneSchema: {};
     response: {};
 }>;
+export declare const renderVoiceAssistantHealthHTML: <TProvider extends string = string>(summary: VoiceAssistantHealthSummary<TProvider>) => string;
+export declare const summarizeVoiceAssistantHealth: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => Promise<VoiceAssistantHealthSummary<TProvider>>;

package/dist/{assistantMemory.d.ts → core/assistantMemory.d.ts}

@@ -1,5 +1,5 @@
-import type { VoiceSessionRecord } from './types';
-import type { VoiceTraceEventStore } from './trace';
+import type { VoiceSessionRecord } from "./types";
+import type { VoiceTraceEventStore } from "./trace";
 export type VoiceAssistantMemoryRecord<TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>> = {
     assistantId: string;
     createdAt: number;
@@ -24,7 +24,7 @@ export type VoiceAssistantMemoryStore<TRecord extends VoiceAssistantMemoryRecord
         assistantId: string;
         namespace?: string;
     }) => Promise<TRecord[]>;
-    set: (input: Omit<TRecord, 'createdAt' | 'updatedAt'> & {
+    set: (input: Omit<TRecord, "createdAt" | "updatedAt"> & {
         createdAt?: number;
         updatedAt?: number;
     }) => Promise<TRecord>;
@@ -46,6 +46,13 @@ export type VoiceAssistantMemoryHandle<TRecord extends VoiceAssistantMemoryRecor
     namespace: string;
     set: <TValue = unknown>(key: string, value: TValue, metadata?: Record<string, unknown>) => Promise<TRecord>;
 };
+export declare const createVoiceAssistantMemoryHandle: <TContext, TSession extends VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(input: {
+    assistantId: string;
+    context: TContext;
+    memory: VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+    session: TSession;
+    trace?: VoiceTraceEventStore;
+}) => Promise<VoiceAssistantMemoryHandle<TRecord>>;
 export declare const createVoiceAssistantMemoryRecord: <TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>>(input: Omit<VoiceAssistantMemoryRecord<TValue, TMetadata>, "createdAt" | "updatedAt"> & {
     createdAt?: number;
     updatedAt?: number;
@@ -54,10 +61,3 @@ export declare const createVoiceMemoryAssistantMemoryStore: <TRecord extends Voi
 export declare const resolveVoiceAssistantMemoryNamespace: <TContext, TSession extends VoiceSessionRecord>(input: VoiceAssistantMemoryNamespaceInput<TContext, TSession> & {
     memory: VoiceAssistantMemoryOptions<TContext, TSession>;
 }) => Promise<string>;
-export declare const createVoiceAssistantMemoryHandle: <TContext, TSession extends VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(input: {
-    assistantId: string;
-    context: TContext;
-    memory: VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
-    session: TSession;
-    trace?: VoiceTraceEventStore;
-}) => Promise<VoiceAssistantMemoryHandle<TRecord>>;

package/dist/core/assistantMode.d.ts

@@ -0,0 +1,22 @@
+import type { CreateVoiceSessionOptions, VoiceSessionRecord } from "./types";
+export type VoiceAssistantMode = "cascade" | "s2s";
+export type VoiceSemanticVADConfig = {
+    createResponseAutomatically?: boolean;
+    eagerness?: "auto" | "high" | "low" | "medium";
+    silenceDurationMs?: number;
+};
+export type VoiceAssistantModality = "audio" | "text";
+export declare const resolveVoiceAssistantMode: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: Pick<CreateVoiceSessionOptions<TContext, TSession, TResult>, "realtime" | "stt" | "tts"> & {
+    assistantMode?: VoiceAssistantMode;
+}) => VoiceAssistantMode;
+export type VoiceAssistantModeDescriptor = {
+    hasRealtime: boolean;
+    hasSTT: boolean;
+    hasTTS: boolean;
+    mode: VoiceAssistantMode;
+    modalities: VoiceAssistantModality[];
+};
+export declare const describeVoiceAssistantMode: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: Pick<CreateVoiceSessionOptions<TContext, TSession, TResult>, "realtime" | "stt" | "tts"> & {
+    assistantMode?: VoiceAssistantMode;
+    modalities?: ReadonlyArray<VoiceAssistantModality>;
+}) => VoiceAssistantModeDescriptor;

package/dist/{audioConditioning.d.ts → core/audioConditioning.d.ts}

@@ -1,3 +1,3 @@
-import type { AudioChunk, VoiceAudioConditioningConfig, VoiceResolvedAudioConditioningConfig } from './types';
-export declare const resolveAudioConditioningConfig: (config?: VoiceAudioConditioningConfig) => VoiceResolvedAudioConditioningConfig | undefined;
+import type { AudioChunk, VoiceAudioConditioningConfig, VoiceResolvedAudioConditioningConfig } from "./types";
 export declare const conditionAudioChunk: (audio: AudioChunk, config?: VoiceResolvedAudioConditioningConfig) => AudioChunk;
+export declare const resolveAudioConditioningConfig: (config?: VoiceAudioConditioningConfig) => VoiceResolvedAudioConditioningConfig | undefined;

package/dist/core/audit.d.ts

@@ -0,0 +1,131 @@
+export type VoiceAuditEventType = "handoff" | "operator.action" | "profile.switch" | "provider.call" | "retention.policy" | "tool.call";
+export type VoiceAuditActor = {
+    id: string;
+    kind: "agent" | "operator" | "system" | "worker";
+    name?: string;
+};
+export type VoiceAuditResource = {
+    id?: string;
+    type: string;
+};
+export type VoiceAuditOutcome = "error" | "skipped" | "success";
+export type VoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
+    action: string;
+    actor?: VoiceAuditActor;
+    at?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: TPayload;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    traceId?: string;
+    type: VoiceAuditEventType;
+};
+export type StoredVoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = Omit<VoiceAuditEvent<TPayload>, "at" | "id"> & {
+    at: number;
+    id: string;
+};
+export type VoiceAuditEventFilter = {
+    actorId?: string;
+    after?: number;
+    afterOrAt?: number;
+    before?: number;
+    beforeOrAt?: number;
+    limit?: number;
+    outcome?: VoiceAuditOutcome | VoiceAuditOutcome[];
+    readWindow?: "recent";
+    resourceId?: string;
+    resourceType?: string;
+    sessionId?: string;
+    traceId?: string;
+    type?: VoiceAuditEventType | VoiceAuditEventType[];
+};
+export type VoiceAuditEventStore<TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent> = {
+    append: (event: VoiceAuditEvent | TEvent) => Promise<TEvent> | TEvent;
+    get: (id: string) => Promise<TEvent | undefined> | TEvent | undefined;
+    list: (filter?: VoiceAuditEventFilter) => Promise<TEvent[]> | TEvent[];
+};
+export type VoiceScopedAuditEventStoreOptions = VoiceAuditEventFilter;
+export type VoiceAuditLogger = {
+    handoff: (input: Omit<VoiceHandoffAuditEventInput, "store">) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    operatorAction: (input: Omit<VoiceOperatorAuditEventInput, "store">) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    providerCall: (input: Omit<VoiceProviderAuditEventInput, "store">) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    record: (event: VoiceAuditEvent) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    retention: (input: Omit<VoiceRetentionAuditEventInput, "store">) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    toolCall: (input: Omit<VoiceToolAuditEventInput, "store">) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+};
+export type VoiceProviderAuditEventInput = {
+    actor?: VoiceAuditActor;
+    cost?: Record<string, unknown>;
+    elapsedMs?: number;
+    error?: string;
+    kind: "llm" | "stt" | "tts" | string;
+    metadata?: Record<string, unknown>;
+    model?: string;
+    outcome: VoiceAuditOutcome;
+    provider: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export type VoiceToolAuditEventInput = {
+    actor?: VoiceAuditActor;
+    elapsedMs?: number;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    toolCallId?: string;
+    toolName: string;
+    traceId?: string;
+};
+export type VoiceHandoffAuditEventInput = {
+    actor?: VoiceAuditActor;
+    fromAgentId?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    reason?: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    target?: string;
+    toAgentId?: string;
+    traceId?: string;
+};
+export type VoiceRetentionAuditEventInput = {
+    actor?: VoiceAuditActor;
+    dryRun: boolean;
+    metadata?: Record<string, unknown>;
+    report: {
+        deletedCount: number;
+        scopes: Array<{
+            deletedCount: number;
+            scope: string;
+            skippedReason?: string;
+        }>;
+    };
+    store: VoiceAuditEventStore;
+};
+export type VoiceOperatorAuditEventInput = {
+    action: string;
+    actor: VoiceAuditActor;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: Record<string, unknown>;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export declare const createVoiceAuditEvent: <TPayload extends Record<string, unknown> = Record<string, unknown>>(event: VoiceAuditEvent<TPayload>) => StoredVoiceAuditEvent<TPayload>;
+export declare const createVoiceAuditLogger: (store: VoiceAuditEventStore) => VoiceAuditLogger;
+export declare const createVoiceMemoryAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>() => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceScopedAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(store: VoiceAuditEventStore<TEvent>, scope: VoiceScopedAuditEventStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const filterVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], filter?: VoiceAuditEventFilter) => TEvent[];
+export declare const recordVoiceAuditEvent: (store: VoiceAuditEventStore, event: VoiceAuditEvent) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceHandoffAuditEvent: (input: VoiceHandoffAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceOperatorAuditEvent: (input: VoiceOperatorAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceProviderAuditEvent: (input: VoiceProviderAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceRetentionAuditEvent: (input: VoiceRetentionAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceToolAuditEvent: (input: VoiceToolAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;

package/dist/core/auditDeliveryRoutes.d.ts

@@ -0,0 +1,85 @@
+import { Elysia } from "elysia";
+import { type VoiceAuditSinkDeliveryQueueStatus, type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore, type VoiceAuditSinkDeliveryWorkerResult } from "./auditSinks";
+export type VoiceAuditDeliveryReport = {
+    checkedAt: number;
+    deliveries: VoiceAuditSinkDeliveryRecord[];
+    filter: VoiceAuditDeliveryFilter;
+    summary: VoiceAuditSinkDeliveryQueueSummary;
+};
+export type VoiceAuditDeliveryDrainWorker = {
+    drain: () => Promise<VoiceAuditSinkDeliveryWorkerResult> | VoiceAuditSinkDeliveryWorkerResult;
+};
+export type VoiceAuditDeliveryDrainReport = VoiceAuditSinkDeliveryWorkerResult & {
+    drainedAt: number;
+};
+export type VoiceAuditDeliveryFilter = {
+    limit?: number;
+    q?: string;
+    status?: VoiceAuditSinkDeliveryQueueStatus | "all";
+};
+export type VoiceAuditDeliveryRoutesOptions = {
+    deadLetters?: VoiceAuditSinkDeliveryStore;
+    filter?: VoiceAuditDeliveryFilter;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    limit?: number;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceAuditDeliveryReport) => string | Promise<string>;
+    store: VoiceAuditSinkDeliveryStore;
+    title?: string;
+    worker?: VoiceAuditDeliveryDrainWorker;
+    workerPath?: false | string;
+};
+export declare const resolveVoiceAuditDeliveryFilter: (query?: Record<string, unknown>, base?: VoiceAuditDeliveryFilter) => VoiceAuditDeliveryFilter;
+export declare const buildVoiceAuditDeliveryReport: (options: VoiceAuditDeliveryRoutesOptions, filter?: VoiceAuditDeliveryFilter) => Promise<VoiceAuditDeliveryReport>;
+export declare const createVoiceAuditDeliveryHTMLHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceAuditDeliveryJSONHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceAuditDeliveryReport>;
+export declare const createVoiceAuditDeliveryRoutes: (options: VoiceAuditDeliveryRoutesOptions) => 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: VoiceAuditDeliveryReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceAuditDeliveryHTML: (report: VoiceAuditDeliveryReport, options?: {
+    title?: string;
+    workerPath?: false | string;
+}) => string;

package/dist/core/auditExport.d.ts

@@ -0,0 +1,34 @@
+import type { StoredVoiceAuditEvent, VoiceAuditEventFilter, VoiceAuditEventStore } from "./audit";
+import { type VoiceTraceRedactionConfig } from "./trace";
+import { type VoiceAuditTrailSummary } from "./auditRoutes";
+export type VoiceAuditExport = {
+    events: StoredVoiceAuditEvent[];
+    exportedAt: number;
+    filter?: VoiceAuditEventFilter;
+    redacted: boolean;
+    summary: VoiceAuditTrailSummary;
+};
+export declare const exportVoiceAuditTrail: (input: {
+    filter?: VoiceAuditEventFilter;
+    redact?: VoiceTraceRedactionConfig;
+    store: VoiceAuditEventStore;
+}) => Promise<VoiceAuditExport>;
+export declare const redactVoiceAuditEvent: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(event: TEvent, options?: VoiceTraceRedactionConfig) => TEvent;
+export declare const redactVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], options?: VoiceTraceRedactionConfig) => TEvent[];
+export declare const buildVoiceAuditExport: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => {
+    events: StoredVoiceAuditEvent[];
+    html: string;
+    markdown: string;
+    summary: VoiceAuditTrailSummary;
+};
+export declare const renderVoiceAuditHTML: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => string;
+export declare const renderVoiceAuditMarkdown: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => string;

package/dist/core/auditRoutes.d.ts

@@ -0,0 +1,66 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceAuditEvent, VoiceAuditEventFilter, VoiceAuditEventStore, VoiceAuditEventType } from "./audit";
+export type VoiceAuditTrailSummary = {
+    byActor: Array<[string, number]>;
+    byOutcome: Array<[string, number]>;
+    byResourceType: Array<[string, number]>;
+    byType: Array<[VoiceAuditEventType, number]>;
+    errors: number;
+    latestAt?: number;
+    total: number;
+};
+export type VoiceAuditTrailReport = {
+    checkedAt: number;
+    events: StoredVoiceAuditEvent[];
+    filter: VoiceAuditEventFilter;
+    summary: VoiceAuditTrailSummary;
+};
+export type VoiceAuditTrailOptions = {
+    filter?: VoiceAuditEventFilter;
+    limit?: number;
+    store: VoiceAuditEventStore;
+};
+export type VoiceAuditTrailRoutesOptions = VoiceAuditTrailOptions & {
+    exportHtmlPath?: false | string;
+    exportPath?: false | string;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceAuditTrailReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceAuditTrailReport: (options: VoiceAuditTrailOptions) => Promise<VoiceAuditTrailReport>;
+export declare const createVoiceAuditTrailRoutes: (options: VoiceAuditTrailRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceAuditTrailHTML: (report: VoiceAuditTrailReport, options?: {
+    title?: string;
+}) => string;
+export declare const resolveVoiceAuditTrailFilter: (query?: Record<string, unknown>, base?: VoiceAuditEventFilter) => VoiceAuditEventFilter;
+export declare const summarizeVoiceAuditTrail: (events: StoredVoiceAuditEvent[]) => VoiceAuditTrailSummary;