@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.300

package/dist/angular/voice-agent-squad-status.service.d.ts

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

package/dist/angular/voice-campaign-dialer-proof.service.d.ts

@@ -0,0 +1,14 @@
+import { type VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../campaignDialers';
+export declare class VoiceCampaignDialerProofService {
+    connect(path?: string, options?: VoiceCampaignDialerProofClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+        report: import("@angular/core").Signal<VoiceCampaignDialerProofReport | undefined>;
+        runProof: () => Promise<VoiceCampaignDialerProofReport>;
+        status: import("@angular/core").Signal<VoiceCampaignDialerProofStatus | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

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

@@ -15,6 +15,7 @@ export declare class VoiceControllerService {
         isConnected: import("@angular/core").Signal<boolean>;
         isRecording: import("@angular/core").Signal<boolean>;
         partial: import("@angular/core").Signal<string>;
+        reconnect: import("@angular/core").Signal<import("..").VoiceReconnectClientState>;
         recordingError: import("@angular/core").Signal<string | null>;
         sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
         sessionId: import("@angular/core").Signal<string | null>;

package/dist/angular/voice-delivery-runtime.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { type VoiceDeliveryRuntimeViewModel } from '../client/deliveryRuntimeWidget';
+export declare class VoiceDeliveryRuntimeComponent implements OnDestroy, OnInit {
+    description?: string;
+    intervalMs?: number;
+    path: string;
+    title?: string;
+    private cleanup;
+    private store?;
+    model: import("@angular/core").WritableSignal<VoiceDeliveryRuntimeViewModel>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    deadLettered(): number;
+    tick(): void;
+    requeueDeadLetters(): void;
+    private options;
+}

package/dist/angular/voice-delivery-runtime.service.d.ts

@@ -0,0 +1,16 @@
+import { type VoiceDeliveryRuntimeClientOptions } from '../client/deliveryRuntime';
+import type { VoiceDeliveryRuntimeReport } from '../deliveryRuntime';
+export declare class VoiceDeliveryRuntimeService {
+    connect(path?: string, options?: VoiceDeliveryRuntimeClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        actionError: import("@angular/core").Signal<string | null>;
+        actionStatus: import("@angular/core").Signal<"completed" | "failed" | "idle" | "running">;
+        isLoading: import("@angular/core").Signal<boolean>;
+        requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+        refresh: () => Promise<VoiceDeliveryRuntimeReport | undefined>;
+        report: import("@angular/core").Signal<VoiceDeliveryRuntimeReport | undefined>;
+        tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-live-ops.service.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceLiveOpsActionResult, type VoiceLiveOpsClientOptions } from '../client/liveOps';
+export declare class VoiceLiveOpsService {
+    connect(options?: VoiceLiveOpsClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isRunning: import("@angular/core").Signal<boolean>;
+        lastResult: import("@angular/core").Signal<VoiceLiveOpsActionResult | undefined>;
+        run: (input: import("..").VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
+        runningAction: import("@angular/core").Signal<"escalate" | "operator-takeover" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
+    };
+}

package/dist/angular/voice-ops-action-center.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceOpsActionCenterClientOptions, type VoiceOpsActionDescriptor, type VoiceOpsActionRunResult } from '../client/opsActionCenter';
+export declare class VoiceOpsActionCenterService {
+    connect(options?: VoiceOpsActionCenterClientOptions): {
+        actions: import("@angular/core").Signal<VoiceOpsActionDescriptor[]>;
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isRunning: import("@angular/core").Signal<boolean>;
+        lastResult: import("@angular/core").Signal<VoiceOpsActionRunResult | undefined>;
+        run: (actionId: string) => Promise<VoiceOpsActionRunResult | undefined>;
+        runningActionId: import("@angular/core").Signal<string | undefined>;
+        setActions: (actions: VoiceOpsActionDescriptor[]) => void;
+    };
+}

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-ops-status.service.d.ts

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

package/dist/angular/voice-platform-coverage.service.d.ts

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

package/dist/angular/voice-proof-trends.service.d.ts

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

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-contracts.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderContractsClientOptions } from '../client/providerContracts';
+import type { VoiceProviderContractMatrixReport } from '../providerStackRecommendations';
+export declare class VoiceProviderContractsService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProviderContractMatrixReport<TProvider> | undefined>;
+        report: import("@angular/core").Signal<VoiceProviderContractMatrixReport<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-readiness-failures.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceReadinessFailuresClientOptions } from '../client/readinessFailures';
+import type { VoiceProductionReadinessReport } from '../productionReadiness';
+export declare class VoiceReadinessFailuresService {
+    connect(path?: string, options?: VoiceReadinessFailuresClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        explanations: import("@angular/core").Signal<import("..").VoiceProductionReadinessCheck[]>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProductionReadinessReport | undefined>;
+        report: import("@angular/core").Signal<VoiceProductionReadinessReport | undefined>;
+        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,11 +8,14 @@ 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>;
         isConnected: import("@angular/core").Signal<boolean>;
         partial: import("@angular/core").Signal<string>;
+        reconnect: import("@angular/core").Signal<import("..").VoiceReconnectClientState>;
         sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
         sessionId: import("@angular/core").Signal<string | null>;
         status: import("@angular/core").Signal<import("..").VoiceSessionStatus | "idle">;

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

@@ -1,5 +1,6 @@
 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;
@@ -12,6 +13,7 @@ export type VoiceAssistantArtifactPlan<TContext = unknown, TSession extends Voic
 };
 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>;
@@ -29,6 +31,16 @@ export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSess
     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;
@@ -83,6 +95,8 @@ export type VoiceAssistantOptions<TContext = unknown, TSession extends VoiceSess
     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'];
 };
@@ -109,6 +123,12 @@ export type VoiceAssistantRunSummary = {
     toolCalls: Record<string, number>;
     transferCount: number;
     variants: Record<string, number>;
+    memory: {
+        deletes: number;
+        gets: number;
+        lists: number;
+        sets: number;
+    };
 };
 export type VoiceAssistantRunsSummary = {
     assistants: VoiceAssistantRunSummary[];

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

@@ -0,0 +1,128 @@
+export type VoiceAuditEventType = 'handoff' | 'operator.action' | '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[];
+    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 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 filterVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], filter?: VoiceAuditEventFilter) => TEvent[];
+export declare const createVoiceMemoryAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>() => VoiceAuditEventStore<TEvent>;
+export declare const recordVoiceAuditEvent: (store: VoiceAuditEventStore, event: VoiceAuditEvent) => 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 recordVoiceToolAuditEvent: (input: VoiceToolAuditEventInput) => 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 recordVoiceRetentionAuditEvent: (input: VoiceRetentionAuditEventInput) => 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 createVoiceAuditLogger: (store: VoiceAuditEventStore) => VoiceAuditLogger;