@absolutejs/voice 0.0.22-beta.44 → 0.0.22-beta.442

package/dist/fileStore.d.ts

@@ -1,15 +1,23 @@
-import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from './assistantMemory';
-import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
-import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { VoiceCampaignStore } from "./campaign";
+import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from "./assistantMemory";
+import type { StoredVoiceIncidentBundleArtifact, VoiceIncidentBundleStore } from "./incidentBundle";
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from "./ops";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
 export type VoiceFileStoreOptions = {
     directory: string;
     pretty?: boolean;
 };
-export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    incidentBundles: VoiceIncidentBundleStore<TIncident>;
     memories: VoiceAssistantMemoryStore<TMemory>;
     reviews: VoiceCallReviewStore<TReview>;
     session: VoiceSessionStore<TSession>;
@@ -20,12 +28,16 @@ export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceS
 export declare const createVoiceFileSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceFileStoreOptions) => VoiceSessionStore<TSession>;
 export declare const createVoiceFileReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceFileStoreOptions) => VoiceCallReviewStore<TArtifact>;
 export declare const createVoiceFileTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceFileStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoiceFileCampaignStore: (options: VoiceFileStoreOptions) => VoiceCampaignStore;
 export declare const createVoiceFileIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceIntegrationEventStore<TEvent>;
 export declare const createVoiceFileExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceFileStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
 export declare const createVoiceFileTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceFileStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceFileTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoiceFileAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceFileStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceFileAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
 export declare const createVoiceFileAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceAssistantMemoryStore<TRecord>;
-export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TMemory>;
+export declare const createVoiceFileIncidentBundleStore: <TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact>(options: VoiceFileStoreOptions) => VoiceIncidentBundleStore<TArtifact>;
+export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery, TIncident, TMemory>;
 export declare const createStoredVoiceCallReviewArtifact: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
     id: string;
 };

package/dist/guardrails.d.ts

@@ -0,0 +1,128 @@
+import { Elysia } from "elysia";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceOnTurnObjectHandler, VoiceRouteResult, VoiceSessionRecord } from "./types";
+import type { VoiceAssistantGuardrails } from "./assistant";
+export type VoiceGuardrailStage = "assistant-output" | "handoff" | "model-input" | "tool-input" | "tool-output" | "transcript";
+export type VoiceGuardrailSeverity = "block" | "warn";
+export type VoiceGuardrailStatus = "blocked" | "pass" | "warn";
+export type VoiceGuardrailRule = {
+    action?: VoiceGuardrailSeverity;
+    description?: string;
+    id: string;
+    label?: string;
+    match: RegExp | string | ((input: VoiceGuardrailEvaluationInput) => boolean | Promise<boolean>);
+    redactWith?: string;
+    stages?: VoiceGuardrailStage[];
+};
+export type VoiceGuardrailEvaluationInput = {
+    content?: unknown;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    turnId?: string;
+};
+export type VoiceGuardrailFinding = {
+    action: VoiceGuardrailSeverity;
+    description?: string;
+    label: string;
+    ruleId: string;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailDecision = {
+    allowed: boolean;
+    checkedAt: number;
+    content?: unknown;
+    findings: VoiceGuardrailFinding[];
+    redactedContent?: unknown;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    status: VoiceGuardrailStatus;
+    turnId?: string;
+};
+export type VoiceGuardrailPolicy = {
+    defaultAction?: VoiceGuardrailSeverity;
+    id: string;
+    label?: string;
+    rules: VoiceGuardrailRule[];
+};
+export type VoiceGuardrailReport = {
+    checkedAt: number;
+    decisions: VoiceGuardrailDecision[];
+    failed: number;
+    policies: Array<{
+        id: string;
+        label?: string;
+        rules: number;
+    }>;
+    status: "fail" | "pass" | "warn";
+    summary: {
+        blocked: number;
+        passed: number;
+        warned: number;
+    };
+    total: number;
+};
+export type VoiceGuardrailRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    policies?: VoiceGuardrailPolicy[];
+    source?: ((input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision | VoiceGuardrailReport> | VoiceGuardrailDecision | VoiceGuardrailReport) | VoiceGuardrailDecision | VoiceGuardrailReport;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntimeBlockInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    decision: VoiceGuardrailDecision;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailRuntimeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    blockResult?: (input: VoiceGuardrailRuntimeBlockInput<TContext, TSession, TResult>) => Promise<VoiceRouteResult<TResult>> | VoiceRouteResult<TResult>;
+    name?: string;
+    policies: VoiceGuardrailPolicy[];
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntime<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistantGuardrails: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    evaluate: (input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+    wrapTool: <TArgs extends Record<string, unknown>, TToolResult>(tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>) => VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>;
+    wrapTools: (tools: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>) => Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+};
+export declare const evaluateVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy, input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+export declare const buildVoiceGuardrailReport: (input?: {
+    decisions: VoiceGuardrailDecision[];
+    policies?: VoiceGuardrailPolicy[];
+}) => VoiceGuardrailReport;
+export declare const createVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy) => VoiceGuardrailPolicy;
+export declare const createVoiceGuardrailRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceGuardrailRuntimeOptions<TContext, TSession, TResult>) => VoiceGuardrailRuntime<TContext, TSession, TResult>;
+export declare const voiceGuardrailPolicyPresets: {
+    supportSafeDefaults: VoiceGuardrailPolicy;
+};
+export declare const renderVoiceGuardrailMarkdown: (report: VoiceGuardrailReport) => string;
+export declare const createVoiceGuardrailRoutes: (options?: VoiceGuardrailRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/handoff.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceHandoffAction, VoiceHandoffAdapter, VoiceHandoffConfig, VoiceHandoffDeliveryStore, VoiceHandoffInput, VoiceHandoffResult, VoiceSessionRecord, StoredVoiceHandoffDelivery } from './types';
+import type { VoiceHandoffAction, VoiceHandoffAdapter, VoiceHandoffConfig, VoiceHandoffDeliveryStore, VoiceHandoffInput, VoiceHandoffResult, VoiceSessionRecord, StoredVoiceHandoffDelivery } from "./types";
 type MaybePromise<T> = T | Promise<T>;
 export type VoiceHandoffDelivery = VoiceHandoffResult & {
     adapterId: string;
@@ -8,16 +8,16 @@ export type VoiceHandoffDeliveryRecord<TContext = unknown, TSession extends Voic
 export type VoiceHandoffFanoutResult = {
     action: VoiceHandoffAction;
     deliveries: Record<string, VoiceHandoffDelivery>;
-    status: VoiceHandoffResult['status'];
+    status: VoiceHandoffResult["status"];
 };
-export type VoiceHandoffDeliveryRecordInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceHandoffInput<TContext, TSession, TResult>, 'api'> & {
+export type VoiceHandoffDeliveryRecordInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceHandoffInput<TContext, TSession, TResult>, "api"> & {
     id?: string;
 };
 export type VoiceQueuedHandoffDeliveryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
-    api: VoiceHandoffInput<TContext, TSession, TResult>['api'];
+    api: VoiceHandoffInput<TContext, TSession, TResult>["api"];
     delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
-    failMode?: VoiceHandoffConfig<TContext, TSession, TResult>['failMode'];
+    failMode?: VoiceHandoffConfig<TContext, TSession, TResult>["failMode"];
 };
 export type VoiceWebhookHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     actions?: VoiceHandoffAction[];
@@ -26,7 +26,7 @@ export type VoiceWebhookHandoffAdapterOptions<TContext = unknown, TSession exten
     headers?: Record<string, string>;
     id: string;
     kind?: string;
-    method?: 'POST' | 'PUT' | 'PATCH';
+    method?: "POST" | "PUT" | "PATCH";
     signingSecret?: string;
     timeoutMs?: number;
     url: string;

package/dist/handoffHealth.d.ts

@@ -1,6 +1,6 @@
-import { Elysia } from 'elysia';
-import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
-export type VoiceHandoffHealthStatus = 'delivered' | 'failed' | 'skipped';
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceHandoffHealthStatus = "delivered" | "failed" | "skipped";
 export type VoiceHandoffHealthDelivery = {
     adapterId: string;
     adapterKind?: string;
@@ -31,8 +31,8 @@ export type VoiceHandoffHealthSummaryOptions = {
     events?: StoredVoiceTraceEvent[];
     limit?: number;
     q?: string;
-    replayHref?: false | string | ((event: Omit<VoiceHandoffHealthEvent, 'replayHref'>) => string);
-    status?: VoiceHandoffHealthStatus | 'all';
+    replayHref?: false | string | ((event: Omit<VoiceHandoffHealthEvent, "replayHref">) => string);
+    status?: VoiceHandoffHealthStatus | "all";
     store?: VoiceTraceEventStore;
 };
 export type VoiceHandoffHealthHTMLHandlerOptions = VoiceHandoffHealthSummaryOptions & {

package/dist/htmx.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceHTMXConfig, VoiceHTMXRenderConfig, VoiceHTMXRenderInput, VoiceHTMXTargets, VoiceSessionRecord } from './types';
+import type { VoiceHTMXConfig, VoiceHTMXRenderConfig, VoiceHTMXRenderInput, VoiceHTMXTargets, VoiceSessionRecord } from "./types";
 type ResolvedVoiceHTMXRenderConfig<TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Required<VoiceHTMXRenderConfig<TSession, TResult>>;
 export declare const resolveVoiceHTMXTargets: (custom?: Partial<VoiceHTMXTargets>) => VoiceHTMXTargets;
 export declare const resolveVoiceHTMXRenderers: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(custom?: VoiceHTMXConfig<TSession, TResult>) => ResolvedVoiceHTMXRenderConfig<TSession, TResult>;

package/dist/incidentBundle.d.ts

@@ -0,0 +1,119 @@
+import { Elysia } from "elysia";
+import { type VoiceOperationsRecord, type VoiceOperationsRecordOptions } from "./operationsRecord";
+import type { VoiceIncidentRecoveryOutcomeReport } from "./incidentTimeline";
+import { type VoiceTraceRedactionConfig } from "./trace";
+export type VoiceIncidentBundleFormat = "json" | "markdown";
+export type VoiceIncidentBundle = {
+    auditMarkdown?: string;
+    exportedAt: number;
+    formatVersion: 1;
+    markdown: string;
+    record: VoiceOperationsRecord;
+    recoveryOutcomes?: VoiceIncidentRecoveryOutcomeReport;
+    redacted: boolean;
+    sessionId: string;
+    summary: VoiceIncidentBundleSummary;
+    traceMarkdown: string;
+};
+export type StoredVoiceIncidentBundleArtifact = {
+    bundle: VoiceIncidentBundle;
+    createdAt: number;
+    expiresAt?: number;
+    id: string;
+    metadata?: Record<string, unknown>;
+    redacted: boolean;
+    sessionId: string;
+};
+export type VoiceIncidentBundleStoreFilter = {
+    expiredAt?: number;
+    sessionId?: string;
+};
+export type VoiceIncidentBundleStore<TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact> = {
+    get: (id: string) => Promise<TArtifact | undefined> | TArtifact | undefined;
+    list: (filter?: VoiceIncidentBundleStoreFilter) => Promise<TArtifact[]> | TArtifact[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, artifact: TArtifact) => Promise<void> | void;
+};
+export type VoiceIncidentBundleSummary = {
+    auditEvents: number;
+    durationMs?: number;
+    errors: number;
+    handoffs: number;
+    providers: string[];
+    sessionId: string;
+    status: VoiceOperationsRecord["status"];
+    tools: number;
+    traceEvents: number;
+    turns: number;
+};
+export type VoiceIncidentBundleOptions = VoiceOperationsRecordOptions & {
+    redact?: VoiceTraceRedactionConfig;
+    recoveryOutcomes?: VoiceIncidentRecoveryOutcomeReport;
+    title?: string;
+};
+export type VoiceIncidentBundleRoutesOptions = Omit<VoiceIncidentBundleOptions, "sessionId"> & {
+    headers?: HeadersInit;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceIncidentBundleArtifactOptions = {
+    createdAt?: number;
+    expiresAt?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    ttlMs?: number;
+};
+export type VoiceIncidentBundleRetentionOptions = {
+    before?: number;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    expiredAt?: number;
+    keepNewest?: number;
+    limit?: number;
+    store: VoiceIncidentBundleStore;
+};
+export type VoiceIncidentBundleRetentionReport = {
+    deleted: StoredVoiceIncidentBundleArtifact[];
+    deletedCount: number;
+    deletedIds: string[];
+    dryRun: boolean;
+    scannedCount: number;
+};
+export declare const createVoiceMemoryIncidentBundleStore: <TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact>() => VoiceIncidentBundleStore<TArtifact>;
+export declare const createStoredVoiceIncidentBundleArtifact: (bundle: VoiceIncidentBundle, options?: VoiceIncidentBundleArtifactOptions) => StoredVoiceIncidentBundleArtifact;
+export declare const saveVoiceIncidentBundleArtifact: (input: {
+    bundle: VoiceIncidentBundle;
+    options?: VoiceIncidentBundleArtifactOptions;
+    store: VoiceIncidentBundleStore;
+}) => Promise<StoredVoiceIncidentBundleArtifact>;
+export declare const pruneVoiceIncidentBundleArtifacts: (options: VoiceIncidentBundleRetentionOptions) => Promise<VoiceIncidentBundleRetentionReport>;
+export declare const buildVoiceIncidentBundle: (options: VoiceIncidentBundleOptions) => Promise<VoiceIncidentBundle>;
+export declare const createVoiceIncidentBundleRoutes: (options: VoiceIncidentBundleRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/incidentTimeline.d.ts

@@ -0,0 +1,259 @@
+import { Elysia } from "elysia";
+import type { VoiceFailureReplayReport, VoiceOperationsRecord } from "./operationsRecord";
+import type { VoiceOperationalStatusReport } from "./operationalStatus";
+import type { VoiceOpsRecoveryReport } from "./opsRecovery";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+import type { VoiceAuditEventStore } from "./audit";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceMonitorIssue } from "./voiceMonitoring";
+export type VoiceIncidentTimelineStatus = "fail" | "pass" | "warn";
+export type VoiceIncidentTimelineSeverity = "critical" | "info" | "warn";
+export type VoiceIncidentTimelineAction = {
+    href?: string;
+    label: string;
+    method?: "GET" | "POST";
+};
+export type VoiceIncidentRecoveryAction = {
+    detail?: string;
+    disabled?: boolean;
+    eventId?: string;
+    href?: string;
+    id: string;
+    label: string;
+    method?: "GET" | "POST";
+    sessionId?: string;
+};
+export type VoiceIncidentRecoveryActionResult = {
+    actionId: string;
+    afterStatus?: VoiceIncidentTimelineStatus;
+    beforeStatus?: VoiceIncidentTimelineStatus;
+    detail?: string;
+    href?: string;
+    ok: boolean;
+    status?: string;
+};
+export type VoiceIncidentRecoveryActionHandlerInput = {
+    action: VoiceIncidentRecoveryAction;
+    actionId: string;
+    report: VoiceIncidentTimelineReport;
+    request: Request;
+};
+export type VoiceIncidentRecoveryActionHandler = (input: VoiceIncidentRecoveryActionHandlerInput) => Promise<VoiceIncidentRecoveryActionResult> | VoiceIncidentRecoveryActionResult;
+export type VoiceIncidentRecoveryOutcome = "failed" | "improved" | "regressed" | "unchanged";
+export type VoiceIncidentRecoveryOutcomeEntry = {
+    actionId: string;
+    afterStatus?: VoiceIncidentTimelineStatus;
+    at: number;
+    beforeStatus?: VoiceIncidentTimelineStatus;
+    detail?: string;
+    eventId: string;
+    outcome: VoiceIncidentRecoveryOutcome;
+    status?: number;
+    traceId?: string;
+};
+export type VoiceIncidentRecoveryOutcomeReport = {
+    checkedAt: number;
+    entries: VoiceIncidentRecoveryOutcomeEntry[];
+    failed: number;
+    improved: number;
+    regressed: number;
+    total: number;
+    unchanged: number;
+};
+export type VoiceIncidentRecoveryTrendStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceIncidentRecoveryTrendSloMode = "aggregate" | "latest";
+export type VoiceIncidentRecoveryTrendSloOptions = {
+    href?: string;
+    label?: string;
+    maxFailureRate?: number;
+    maxRegressionRate?: number;
+    maxUnchangedRate?: number;
+    minActions?: number;
+    minCycles?: number;
+    minImprovementRate?: number;
+    warnWhenEmpty?: boolean;
+    mode?: VoiceIncidentRecoveryTrendSloMode;
+};
+export type VoiceIncidentRecoveryTrendCycle = {
+    checkedAt: number;
+    failed: number;
+    failureRate: number;
+    improved: number;
+    improvementRate: number;
+    regressed: number;
+    regressionRate: number;
+    total: number;
+    unchanged: number;
+    unchangedRate: number;
+};
+export type VoiceIncidentRecoveryTrendReport = {
+    checkedAt: number;
+    cycles: VoiceIncidentRecoveryTrendCycle[];
+    latest?: VoiceIncidentRecoveryTrendCycle;
+    previous?: VoiceIncidentRecoveryTrendCycle;
+    status: VoiceIncidentRecoveryTrendStatus;
+    summary: {
+        cycles: number;
+        failed: number;
+        failureRate: number;
+        improved: number;
+        improvementRate: number;
+        regressed: number;
+        regressionRate: number;
+        total: number;
+        unchanged: number;
+        unchangedRate: number;
+    };
+    trend: {
+        failureRateDelta?: number;
+        improvementRateDelta?: number;
+        regressionRateDelta?: number;
+        unchangedRateDelta?: number;
+    };
+};
+export type VoiceIncidentRecoveryOutcomeOptions = {
+    audit?: VoiceAuditEventStore;
+    limit?: number;
+};
+export type VoiceIncidentRecoveryOutcomeReadinessOptions = {
+    failOnFailed?: boolean;
+    failOnRegressed?: boolean;
+    href?: string;
+    label?: string;
+    maxUnchanged?: number;
+    warnWhenEmpty?: boolean;
+};
+export type VoiceIncidentTimelineEvent = {
+    action?: VoiceIncidentTimelineAction;
+    at: number;
+    category: "call" | "delivery" | "failure-replay" | "monitor" | "operational-status" | "readiness" | "recovery";
+    detail?: string;
+    href?: string;
+    id: string;
+    label: string;
+    sessionId?: string;
+    severity: VoiceIncidentTimelineSeverity;
+    source: string;
+    value?: number | string;
+};
+export type VoiceIncidentTimelineReport = {
+    actions: VoiceIncidentRecoveryAction[];
+    events: VoiceIncidentTimelineEvent[];
+    generatedAt: number;
+    links: VoiceIncidentTimelineLinks;
+    status: VoiceIncidentTimelineStatus;
+    summary: {
+        critical: number;
+        info: number;
+        total: number;
+        warn: number;
+    };
+    windowMs?: number;
+};
+export type VoiceIncidentTimelineValue<TValue> = TValue | (() => Promise<TValue> | TValue);
+export type VoiceIncidentTimelineLinks = {
+    callDebugger?: string | ((sessionId: string) => string);
+    deliveryRuntime?: string;
+    failureReplay?: string | ((sessionId: string) => string);
+    monitorIssues?: string;
+    operationalStatus?: string;
+    operationsRecords?: string | ((sessionId: string) => string);
+    productionReadiness?: string;
+    proofPack?: string;
+    supportBundle?: string | ((sessionId: string) => string);
+};
+export type VoiceIncidentTimelineOptions = {
+    failureReplays?: VoiceIncidentTimelineValue<readonly VoiceFailureReplayReport[]>;
+    links?: VoiceIncidentTimelineLinks;
+    limit?: number;
+    monitorIssues?: VoiceIncidentTimelineValue<readonly VoiceMonitorIssue[]>;
+    now?: number;
+    operationalStatus?: VoiceIncidentTimelineValue<VoiceOperationalStatusReport>;
+    operationsRecords?: VoiceIncidentTimelineValue<readonly VoiceOperationsRecord[]>;
+    opsRecovery?: VoiceIncidentTimelineValue<VoiceOpsRecoveryReport>;
+    recoveryActions?: readonly VoiceIncidentRecoveryAction[] | ((input: {
+        events: readonly VoiceIncidentTimelineEvent[];
+        report: Omit<VoiceIncidentTimelineReport, "actions">;
+    }) => Promise<readonly VoiceIncidentRecoveryAction[]> | readonly VoiceIncidentRecoveryAction[]);
+    windowMs?: number;
+};
+export type VoiceIncidentTimelineRoutesOptions = VoiceIncidentTimelineOptions & {
+    actionHandlers?: Record<string, VoiceIncidentRecoveryActionHandler>;
+    actionPath?: false | string;
+    audit?: VoiceAuditEventStore;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceIncidentTimelineReport) => string | Promise<string>;
+    recoveryOutcomeHtmlPath?: false | string;
+    recoveryOutcomePath?: false | string;
+    recoveryTrendHtmlPath?: false | string;
+    recoveryTrendMarkdownPath?: false | string;
+    recoveryTrendPath?: false | string;
+    recoveryTrendReports?: VoiceIncidentRecoveryOutcomeReport[] | (() => VoiceIncidentRecoveryOutcomeReport[] | Promise<VoiceIncidentRecoveryOutcomeReport[]>);
+    title?: string;
+    trace?: VoiceTraceEventStore;
+};
+export declare const buildVoiceIncidentRecoveryOutcomeReport: (options: VoiceIncidentRecoveryOutcomeOptions) => Promise<VoiceIncidentRecoveryOutcomeReport>;
+export declare const renderVoiceIncidentRecoveryOutcomeHTML: (report: VoiceIncidentRecoveryOutcomeReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceIncidentRecoveryOutcomeReadinessCheck: (report: VoiceIncidentRecoveryOutcomeReport, options?: VoiceIncidentRecoveryOutcomeReadinessOptions) => VoiceProductionReadinessCheck;
+export declare const buildVoiceIncidentRecoveryTrendSLOReadinessCheck: (report: VoiceIncidentRecoveryTrendReport, options?: VoiceIncidentRecoveryTrendSloOptions) => VoiceProductionReadinessCheck;
+export declare const buildVoiceIncidentRecoveryTrendReport: (reports?: readonly VoiceIncidentRecoveryOutcomeReport[]) => VoiceIncidentRecoveryTrendReport;
+export declare const renderVoiceIncidentRecoveryTrendMarkdown: (report: VoiceIncidentRecoveryTrendReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceIncidentRecoveryTrendHTML: (report: VoiceIncidentRecoveryTrendReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceIncidentTimelineReport: (options: VoiceIncidentTimelineOptions) => Promise<VoiceIncidentTimelineReport>;
+export declare const renderVoiceIncidentTimelineMarkdown: (report: VoiceIncidentTimelineReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceIncidentTimelineHTML: (report: VoiceIncidentTimelineReport, options?: {
+    actionPath?: string;
+    title?: string;
+}) => string;
+export declare const createVoiceIncidentTimelineRoutes: (options: VoiceIncidentTimelineRoutesOptions) => 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: {};
+}>;