@absolutejs/voice 0.0.22-beta.497 → 0.0.22-beta.499

package/dist/midCallSummary.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceLLMJudgeCompletion } from "./llmJudge";
+export type MidCallSummary = {
+    generatedAt: number;
+    summary: string;
+    topicalShift?: boolean;
+    turnCount: number;
+};
+export type CreateMidCallSummarizerOptions = {
+    completion: VoiceLLMJudgeCompletion;
+    /** Force a summary every N turns. Default 6. */
+    everyTurns?: number;
+    /** Force a summary at most every M ms. Default 60_000. */
+    minIntervalMs?: number;
+    /** Maximum chars to include in the system prompt. Default 600. */
+    summaryMaxChars?: number;
+    systemPrompt?: string;
+};
+export type MidCallSummarizer = {
+    evaluate: (input: {
+        session: VoiceSessionRecord;
+        turn?: VoiceTurnRecord;
+    }) => Promise<MidCallSummary | undefined>;
+    latest: () => MidCallSummary | undefined;
+};
+export declare const createMidCallSummarizer: (options: CreateMidCallSummarizerOptions) => MidCallSummarizer;
+export declare const extractTranscriptText: (transcripts: Transcript[]) => string;

package/dist/recordingRedaction.d.ts

@@ -0,0 +1,18 @@
+import type { Transcript } from "./types";
+import { type VoiceRedactionPattern } from "./redaction";
+export type VoiceRecordingRedactionRange = {
+    endMs: number;
+    label?: string;
+    startMs: number;
+};
+export type DeriveVoiceRecordingRedactionRangesInput = {
+    /** When the recording starts in epoch ms; used to convert absolute timestamps if transcripts use them. */
+    recordingStartedAtEpochMs?: number;
+    /** Optional padding around redaction ranges, in ms (default 100). */
+    paddingMs?: number;
+    /** Patterns to test against transcripts. Defaults to DEFAULT_VOICE_REDACTION_PATTERNS. */
+    patterns?: ReadonlyArray<VoiceRedactionPattern>;
+    /** Transcripts to scan. */
+    transcripts: ReadonlyArray<Transcript>;
+};
+export declare const deriveVoiceRecordingRedactionRanges: (input: DeriveVoiceRecordingRedactionRangesInput) => VoiceRecordingRedactionRange[];

package/dist/recordingStore.d.ts

@@ -11,11 +11,50 @@ export type VoiceRecordingArtifact = {
 export type StoredVoiceRecordingArtifact = VoiceRecordingArtifact & {
     recordingUrl?: string;
 };
+export type VoiceRecordingEncoderInput = {
+    channel: VoiceRecordingChannel;
+    format: AudioFormat;
+    pcm: Uint8Array;
+    sessionId: string;
+};
+export type VoiceRecordingEncoderResult = {
+    bytes: Uint8Array;
+    contentType: string;
+    extension: string;
+};
+export type VoiceRecordingEncoder = {
+    encode: (input: VoiceRecordingEncoderInput) => Promise<VoiceRecordingEncoderResult> | VoiceRecordingEncoderResult;
+    kind: string;
+};
 export type VoiceRecordingStore = {
     get: (sessionId: string, channel: VoiceRecordingChannel) => Promise<StoredVoiceRecordingArtifact | undefined>;
     list: (sessionId: string) => Promise<StoredVoiceRecordingArtifact[]>;
     put: (artifact: VoiceRecordingArtifact) => Promise<StoredVoiceRecordingArtifact>;
 };
 export declare const encodePcmAsWav: (pcm: Uint8Array, format: AudioFormat) => Uint8Array;
+export type InterleavePcmInput = {
+    /** Mono PCM bytes for the left channel. */
+    left: Uint8Array;
+    /** Mono PCM bytes for the right channel. */
+    right: Uint8Array;
+};
+/**
+ * Interleaves two mono pcm_s16le buffers into a single stereo pcm_s16le
+ * buffer at the same sample rate. Output length is max(left, right) * 2.
+ * The shorter buffer is right-padded with silence to align frame counts.
+ */
+export declare const interleaveStereoPcm: (input: InterleavePcmInput) => Uint8Array;
+export type EncodeStereoWavInput = {
+    format: AudioFormat;
+    left: Uint8Array;
+    right: Uint8Array;
+};
+/**
+ * Builds a stereo WAV file from two mono pcm_s16le channels. Convention:
+ * left = user track, right = assistant track. Review tools can split them
+ * back out with any DAW.
+ */
+export declare const encodeStereoWav: ({ format, left, right, }: EncodeStereoWavInput) => Uint8Array;
+export declare const createVoiceWavRecordingEncoder: () => VoiceRecordingEncoder;
 export declare const computePcmDurationMs: (pcmByteLength: number, format: AudioFormat) => number;
 export declare const createVoiceMemoryRecordingStore: () => VoiceRecordingStore;

package/dist/retention.d.ts

@@ -0,0 +1,37 @@
+export type VoiceRetentionPolicyOptions = {
+    /** Maximum age in milliseconds; events older than this are eligible for purge. */
+    maxAgeMs: number;
+    /** Optional override that returns the timestamp for an event. Defaults to event.at. */
+    resolveAt?: (event: unknown) => number | undefined;
+};
+export type VoiceRetentionStore<TRecord extends {
+    id: string;
+}> = {
+    list: (filter?: Record<string, unknown>) => Promise<TRecord[]> | TRecord[];
+    remove: (id: string) => Promise<void> | void;
+};
+export type VoicePurgeReport = {
+    attempted: number;
+    failed: number;
+    purgedIds: string[];
+    reason: "expired" | "manual";
+    removed: number;
+};
+export declare const purgeVoiceRetentionStore: <TRecord extends {
+    id: string;
+}>(store: VoiceRetentionStore<TRecord>, options: VoiceRetentionPolicyOptions, now?: number) => Promise<VoicePurgeReport>;
+export type VoiceRetentionScheduler = {
+    start: () => void;
+    stop: () => void;
+};
+export type CreateVoiceRetentionSchedulerOptions<TRecord extends {
+    id: string;
+}> = {
+    intervalMs?: number;
+    onReport?: (report: VoicePurgeReport) => void;
+    policy: VoiceRetentionPolicyOptions;
+    store: VoiceRetentionStore<TRecord>;
+};
+export declare const createVoiceRetentionScheduler: <TRecord extends {
+    id: string;
+}>(options: CreateVoiceRetentionSchedulerOptions<TRecord>) => VoiceRetentionScheduler;

package/dist/routeAuth.d.ts

@@ -0,0 +1,58 @@
+import { Elysia } from "elysia";
+export type VoiceRouteAuthDecision = {
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+    status?: number;
+};
+export type VoiceRouteAuthInput = {
+    body?: string;
+    headers: Headers;
+    method: string;
+    url: string;
+};
+export type VoiceRouteAuthVerifier = (input: VoiceRouteAuthInput) => Promise<VoiceRouteAuthDecision> | VoiceRouteAuthDecision;
+export type VoiceRouteAuthOptions = {
+    bypassPaths?: ReadonlyArray<string>;
+    name?: string;
+    verify: VoiceRouteAuthVerifier;
+};
+export declare const createVoiceBearerAuthVerifier: (input: {
+    expectedToken: string;
+    headerName?: string;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceHMACAuthVerifier: (input: {
+    secret: string;
+    toleranceMs?: number;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceRouteAuth: (options: VoiceRouteAuthOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

package/dist/testing/index.js

@@ -5381,6 +5381,39 @@ var encodePcmAsWav = (pcm, format) => {
   output.set(pcm, 44);
   return output;
 };
+var interleaveStereoPcm = (input) => {
+  const leftSamples = new Int16Array(input.left.buffer, input.left.byteOffset, Math.floor(input.left.byteLength / 2));
+  const rightSamples = new Int16Array(input.right.buffer, input.right.byteOffset, Math.floor(input.right.byteLength / 2));
+  const frameCount = Math.max(leftSamples.length, rightSamples.length);
+  const output = new Int16Array(frameCount * 2);
+  for (let frame = 0;frame < frameCount; frame += 1) {
+    output[frame * 2] = leftSamples[frame] ?? 0;
+    output[frame * 2 + 1] = rightSamples[frame] ?? 0;
+  }
+  return new Uint8Array(output.buffer);
+};
+var encodeStereoWav = ({
+  format,
+  left,
+  right
+}) => {
+  if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
+    throw new Error("encodeStereoWav requires raw pcm_s16le format on each channel");
+  }
+  if (format.channels !== 1) {
+    throw new Error("encodeStereoWav expects mono input channels");
+  }
+  const interleaved = interleaveStereoPcm({ left, right });
+  return encodePcmAsWav(interleaved, { ...format, channels: 2 });
+};
+var createVoiceWavRecordingEncoder = () => ({
+  encode: ({ format, pcm }) => ({
+    bytes: encodePcmAsWav(pcm, format),
+    contentType: "audio/wav",
+    extension: "wav"
+  }),
+  kind: "wav"
+});
 var computePcmDurationMs = (pcmByteLength, format) => {
   if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
     return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.497",
+  "version": "0.0.22-beta.499",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",