@absolutejs/voice 0.0.22-beta.1 → 0.0.22-beta.100

package/dist/angular/voice-app-kit-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceAppKitStatusClientOptions } from '../client/appKitStatus';
+import type { VoiceAppKitStatusReport } from '../appKit';
+export declare class VoiceAppKitStatusService {
+    connect(path?: string, options?: VoiceAppKitStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceAppKitStatusReport | undefined>;
+        report: import("@angular/core").Signal<VoiceAppKitStatusReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-ops-status.component.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { type VoiceOpsStatusViewModel } from '../client/opsStatusWidget';
+export declare class VoiceOpsStatusComponent implements OnDestroy, OnInit {
+    description?: string;
+    includeLinks: boolean;
+    intervalMs?: number;
+    path: string;
+    title?: string;
+    private cleanup;
+    private store?;
+    model: import("@angular/core").WritableSignal<VoiceOpsStatusViewModel>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private options;
+}

package/dist/angular/voice-provider-capabilities.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderCapabilitiesClientOptions } from '../client/providerCapabilities';
+import type { VoiceProviderCapabilityReport } from '../providerCapabilities';
+export declare class VoiceProviderCapabilitiesService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        report: import("@angular/core").Signal<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-provider-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare class VoiceProviderStatusService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        providers: import("@angular/core").Signal<VoiceProviderHealthSummary<TProvider>[]>;
+        refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-routing-status.service.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceRoutingStatusClientOptions } from '../client/routingStatus';
+export declare class VoiceRoutingStatusService {
+    connect(path?: string, options?: VoiceRoutingStatusClientOptions): {
+        close: () => void;
+        decision: import("@angular/core").Signal<import("..").VoiceRoutingEvent | null>;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-stream.service.d.ts

@@ -8,6 +8,8 @@ export declare class VoiceStreamService {
             turnId?: string;
         }[]>;
         assistantTexts: import("@angular/core").Signal<string[]>;
+        call: import("@angular/core").Signal<import("..").VoiceCallLifecycleState | null>;
+        callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
         close: () => void;
         endTurn: () => void;
         error: import("@angular/core").Signal<string | null>;

package/dist/angular/voice-trace-timeline.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTraceTimelineClientOptions } from '../client/traceTimeline';
+import type { VoiceTraceTimelineReport } from '../traceTimeline';
+export declare class VoiceTraceTimelineService {
+    connect(path?: string, options?: VoiceTraceTimelineClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTraceTimelineReport | null>;
+        report: import("@angular/core").Signal<VoiceTraceTimelineReport | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-latency.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceTurnLatencyClientOptions } from '../client/turnLatency';
+import type { VoiceTurnLatencyReport } from '../turnLatency';
+export declare class VoiceTurnLatencyService {
+    connect(path?: string, options?: VoiceTurnLatencyClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnLatencyReport | undefined>;
+        runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-quality.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTurnQualityClientOptions } from '../client/turnQuality';
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export declare class VoiceTurnQualityService {
+    connect(path?: string, options?: VoiceTurnQualityClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnQualityReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-workflow-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export declare class VoiceWorkflowStatusService {
+    connect(path?: string, options?: VoiceWorkflowStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+        report: import("@angular/core").Signal<VoiceScenarioEvalReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/appKit.d.ts

@@ -0,0 +1,100 @@
+import { Elysia } from 'elysia';
+import { type VoiceAssistantHealthRoutesOptions } from './assistantHealth';
+import { type VoiceBargeInRoutesOptions } from './bargeInRoutes';
+import { type VoiceDiagnosticsRoutesOptions } from './diagnosticsRoutes';
+import { type VoiceEvalRoutesOptions, type VoiceEvalLink } from './evalRoutes';
+import { type VoiceHandoffHealthRoutesOptions } from './handoffHealth';
+import { type VoiceOpsConsoleRoutesOptions } from './opsConsoleRoutes';
+import { type VoiceProviderHealthRoutesOptions } from './providerHealth';
+import { type VoiceProviderCapabilityRoutesOptions } from './providerCapabilities';
+import { type VoiceProductionReadinessRoutesOptions } from './productionReadiness';
+import { type VoiceQualityRoutesOptions } from './qualityRoutes';
+import { type VoiceResilienceRoutesOptions } from './resilienceRoutes';
+import { type VoiceSessionListRoutesOptions, type VoiceSessionReplayRoutesOptions } from './sessionReplay';
+import { type VoiceTraceEventStore } from './trace';
+import { type VoiceTraceTimelineRoutesOptions } from './traceTimeline';
+export type VoiceAppKitSurface = 'assistantHealth' | 'bargeIn' | 'diagnostics' | 'evals' | 'handoffs' | 'opsConsole' | 'providerCapabilities' | 'providerHealth' | 'productionReadiness' | 'quality' | 'resilience' | 'sessionReplay' | 'sessions' | 'traceTimeline';
+export type VoiceAppKitLink = VoiceEvalLink & {
+    description?: string;
+    statusHref?: string;
+};
+export type VoiceAppKitRoutesOptions<TProvider extends string = string> = {
+    appStatus?: false | VoiceAppKitStatusOptions;
+    assistantHealth?: false | Partial<VoiceAssistantHealthRoutesOptions<TProvider>>;
+    bargeIn?: false | Partial<VoiceBargeInRoutesOptions>;
+    diagnostics?: false | Partial<Omit<VoiceDiagnosticsRoutesOptions, 'store'>>;
+    evals?: false | Partial<VoiceEvalRoutesOptions>;
+    handoffs?: false | Partial<VoiceHandoffHealthRoutesOptions>;
+    headers?: HeadersInit;
+    links?: VoiceAppKitLink[];
+    llmProviders?: readonly TProvider[];
+    name?: string;
+    opsConsole?: false | Partial<VoiceOpsConsoleRoutesOptions>;
+    providerCapabilities?: false | Partial<VoiceProviderCapabilityRoutesOptions<TProvider>>;
+    providerHealth?: false | Partial<VoiceProviderHealthRoutesOptions<TProvider>>;
+    productionReadiness?: false | Partial<VoiceProductionReadinessRoutesOptions>;
+    quality?: false | Partial<VoiceQualityRoutesOptions>;
+    resilience?: false | Partial<VoiceResilienceRoutesOptions>;
+    sessionReplay?: false | Partial<VoiceSessionReplayRoutesOptions>;
+    sessions?: false | Partial<VoiceSessionListRoutesOptions>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    traceTimeline?: false | Partial<VoiceTraceTimelineRoutesOptions>;
+    ttsProviders?: readonly string[];
+};
+export type VoiceAppKitStatus = 'pass' | 'fail';
+export type VoiceAppKitStatusOptions = {
+    include?: {
+        handoffs?: boolean;
+        providers?: boolean;
+        quality?: boolean;
+        sessions?: boolean;
+        workflows?: boolean;
+    };
+    path?: string;
+    preferFixtureWorkflows?: boolean;
+};
+export type VoiceAppKitStatusReport = {
+    checkedAt: number;
+    failed: number;
+    links: VoiceAppKitLink[];
+    passed: number;
+    status: VoiceAppKitStatus;
+    surfaces: {
+        handoffs?: {
+            failed: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        providers?: {
+            degraded: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        quality?: {
+            status: VoiceAppKitStatus;
+        };
+        sessions?: {
+            failed: number;
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+        workflows?: {
+            failed: number;
+            source: 'fixtures' | 'live';
+            status: VoiceAppKitStatus;
+            total: number;
+        };
+    };
+    total: number;
+};
+export type VoiceAppKitRoutes<TProvider extends string = string> = {
+    links: VoiceAppKitLink[];
+    routes: Elysia;
+    surfaces: VoiceAppKitSurface[];
+    use: Elysia['use'];
+};
+export declare const summarizeVoiceAppKitStatus: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => Promise<VoiceAppKitStatusReport>;
+export declare const createVoiceAppKitRoutes: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => VoiceAppKitRoutes<TProvider>;
+export declare const createVoiceAppKit: <TProvider extends string = string>(options: VoiceAppKitRoutesOptions<TProvider>) => VoiceAppKitRoutes<TProvider>;

package/dist/assistant.d.ts

@@ -0,0 +1,143 @@
+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>;
+    preset?: VoiceAssistantPreset | {
+        name: VoiceAssistantPreset;
+        options?: VoiceOutcomeRecipeOptions;
+    };
+};
+export type VoiceAssistantGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    assistantId: string;
+    memory?: VoiceAssistantMemoryHandle;
+};
+export type VoiceAssistantOutputGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceAssistantGuardrailInput<TContext, TSession, TResult> & {
+    result: VoiceRouteResult<TResult>;
+};
+export type VoiceAssistantGuardrails<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    beforeTurn?: (input: VoiceAssistantGuardrailInput<TContext, TSession, TResult>) => Promise<VoiceRouteResult<TResult> | void> | VoiceRouteResult<TResult> | void;
+    afterTurn?: (input: VoiceAssistantOutputGuardrailInput<TContext, TSession, TResult>) => Promise<VoiceRouteResult<TResult> | void> | VoiceRouteResult<TResult> | void;
+};
+export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    id: string;
+    maxToolRounds?: number;
+    metadata?: Record<string, unknown>;
+    model?: VoiceAgentModel<TContext, TSession, TResult>;
+    system?: VoiceAgentOptions<TContext, TSession, TResult>['system'];
+    tools?: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+    weight?: number;
+};
+export type VoiceAssistantMemoryLifecycleInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    assistantId: string;
+    memory: VoiceAssistantMemoryHandle;
+};
+export type VoiceAssistantMemoryLifecycle<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    afterTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult> & {
+        result: VoiceRouteResult<TResult>;
+    }) => Promise<void> | void;
+    beforeTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult>) => Promise<void> | void;
+};
+export type VoiceAssistantExperimentResolverInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    assistantId: string;
+    context: TContext;
+    session: TSession;
+    turnId?: string;
+};
+export type VoiceAssistantExperiment<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    id: string;
+    resolve: (input: VoiceAssistantExperimentResolverInput<TContext, TSession>) => VoiceAssistantVariant<TContext, TSession, TResult>;
+    variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    id: string;
+    selectVariant?: (input: VoiceAssistantExperimentResolverInput<TContext, TSession> & {
+        variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
+    }) => VoiceAssistantVariant<TContext, TSession, TResult> | string | void;
+    variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
+    agent: VoiceAgent<TContext, TSession, TResult>;
+    agents?: never;
+    defaultAgentId?: never;
+    maxHandoffsPerTurn?: never;
+    maxToolRounds?: never;
+    model?: never;
+    selectAgent?: never;
+    system?: never;
+    tools?: never;
+} | {
+    agent?: never;
+    agents: Array<VoiceAgent<TContext, TSession, TResult>>;
+    defaultAgentId: string;
+    maxHandoffsPerTurn?: number;
+    maxToolRounds?: never;
+    model?: never;
+    selectAgent?: VoiceAgentSquadOptions<TContext, TSession, TResult>['selectAgent'];
+    system?: never;
+    tools?: never;
+} | {
+    agent?: never;
+    agents?: never;
+    defaultAgentId?: never;
+    maxHandoffsPerTurn?: never;
+    maxToolRounds?: number;
+    model: VoiceAgentModel<TContext, TSession, TResult>;
+    selectAgent?: never;
+    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> & {
+    artifactPlan?: VoiceAssistantArtifactPlan<TContext, TSession, TResult>;
+    experiment?: VoiceAssistantExperiment<TContext, TSession, TResult>;
+    guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    id: string;
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
+    ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    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'];
+    }) => VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
+};
+export type VoiceAssistantRunSummary = {
+    assistantId: string;
+    artifactPlans: Record<string, number>;
+    averageElapsedMs?: number;
+    blockedGuardrailCount: number;
+    escalationCount: number;
+    experiments: Record<string, number>;
+    guardrailCount: number;
+    outcomes: Record<string, number>;
+    runCount: number;
+    sessions: number;
+    toolCalls: Record<string, number>;
+    transferCount: number;
+    variants: Record<string, number>;
+    memory: {
+        deletes: number;
+        gets: number;
+        lists: number;
+        sets: number;
+    };
+};
+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 summarizeVoiceAssistantRuns: (input: StoredVoiceTraceEvent[] | {
+    events?: StoredVoiceTraceEvent[];
+    store?: VoiceTraceEventStore;
+}) => Promise<VoiceAssistantRunsSummary>;
+export {};

package/dist/assistantHealth.d.ts

@@ -0,0 +1,81 @@
+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;
+    error?: string;
+    provider?: string;
+    rateLimited?: boolean;
+    replayHref?: string;
+    sessionId: string;
+    status?: string;
+    turnId?: string;
+    type: StoredVoiceTraceEvent['type'];
+};
+export type VoiceAssistantHealthSummary<TProvider extends string = string> = {
+    assistantRuns: VoiceAssistantRunsSummary;
+    providerHealth: VoiceProviderHealthSummary<TProvider>[];
+    recentFailures: VoiceAssistantHealthFailure[];
+};
+export type VoiceAssistantHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    maxFailures?: number;
+    providers?: readonly TProvider[];
+    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, 'replayHref'>) => string);
+    store?: VoiceTraceEventStore;
+};
+export type VoiceAssistantHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceAssistantHealthSummaryOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceAssistantHealthSummary<TProvider>) => string | Promise<string>;
+};
+export type VoiceAssistantHealthRoutesOptions<TProvider extends string = string> = VoiceAssistantHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | 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 createVoiceAssistantHealthRoutes: <TProvider extends string = string>(options: VoiceAssistantHealthRoutesOptions<TProvider>) => 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: VoiceAssistantHealthSummary<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/assistantMemory.d.ts

@@ -0,0 +1,63 @@
+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;
+    key: string;
+    metadata?: TMetadata;
+    namespace: string;
+    updatedAt: number;
+    value: TValue;
+};
+export type VoiceAssistantMemoryStore<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<void>;
+    get: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<TRecord | undefined>;
+    list: (input: {
+        assistantId: string;
+        namespace?: string;
+    }) => Promise<TRecord[]>;
+    set: (input: Omit<TRecord, 'createdAt' | 'updatedAt'> & {
+        createdAt?: number;
+        updatedAt?: number;
+    }) => Promise<TRecord>;
+};
+export type VoiceAssistantMemoryNamespaceInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    assistantId: string;
+    context: TContext;
+    session: TSession;
+};
+export type VoiceAssistantMemoryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    namespace: string | ((input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<string> | string);
+    store: VoiceAssistantMemoryStore<TRecord>;
+};
+export type VoiceAssistantMemoryBinding<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+export type VoiceAssistantMemoryHandle<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (key: string) => Promise<void>;
+    get: <TValue = unknown>(key: string) => Promise<TValue | undefined>;
+    list: () => Promise<TRecord[]>;
+    namespace: string;
+    set: <TValue = unknown>(key: string, value: TValue, metadata?: Record<string, unknown>) => Promise<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;
+}) => VoiceAssistantMemoryRecord<TValue, TMetadata>;
+export declare const createVoiceMemoryAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>() => VoiceAssistantMemoryStore<TRecord>;
+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/bargeInRoutes.d.ts

@@ -0,0 +1,56 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceBargeInMonitorSnapshot } from './types';
+export type VoiceBargeInRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: string;
+    name?: string;
+    path?: string;
+    store: VoiceTraceEventStore;
+    thresholdMs?: number;
+    title?: string;
+};
+export type VoiceBargeInReport = VoiceBargeInMonitorSnapshot & {
+    checkedAt: number;
+    sessions: Array<{
+        averageLatencyMs?: number;
+        failed: number;
+        passed: number;
+        sessionId: string;
+        total: number;
+    }>;
+};
+export declare const summarizeVoiceBargeIn: (events: StoredVoiceTraceEvent[], options?: {
+    thresholdMs?: number;
+}) => VoiceBargeInReport;
+export declare const renderVoiceBargeInHTML: (report: VoiceBargeInReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceBargeInRoutes: (options: VoiceBargeInRoutesOptions) => 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/client/actions.d.ts

@@ -7,6 +7,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     type: "audio";
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -20,6 +21,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -33,6 +35,21 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    scenarioId?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    event: import("..").VoiceCallLifecycleEvent;
+    sessionId: string;
+    type: "call_lifecycle";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -47,6 +64,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -60,6 +78,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -73,6 +92,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -87,6 +107,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     turn?: undefined;
@@ -99,6 +120,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;