@absolutejs/voice 0.0.20 → 0.0.22-beta.0

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

@@ -0,0 +1,27 @@
+import type { VoiceControllerOptions, VoiceTurnRecord } from '../types';
+export declare class VoiceControllerService {
+    connect<TResult = unknown>(path: string, options?: VoiceControllerOptions): {
+        assistantAudio: import("@angular/core").Signal<{
+            chunk: Uint8Array;
+            format: import("..").AudioFormat;
+            receivedAt: number;
+            turnId?: string;
+        }[]>;
+        assistantTexts: import("@angular/core").Signal<string[]>;
+        bindHTMX: (options: import("..").VoiceHTMXBindingOptions) => () => void;
+        close: () => void;
+        endTurn: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isConnected: import("@angular/core").Signal<boolean>;
+        isRecording: import("@angular/core").Signal<boolean>;
+        partial: import("@angular/core").Signal<string>;
+        recordingError: import("@angular/core").Signal<string | null>;
+        sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+        sessionId: import("@angular/core").Signal<string | null>;
+        startRecording: () => Promise<void>;
+        status: import("@angular/core").Signal<import("..").VoiceSessionStatus | "idle">;
+        stopRecording: () => void;
+        toggleRecording: () => Promise<void>;
+        turns: import("@angular/core").Signal<VoiceTurnRecord<TResult>[]>;
+    };
+}

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

@@ -1,6 +1,12 @@
 import type { VoiceConnectionOptions, VoiceTurnRecord } from '../types';
 export declare class VoiceStreamService {
     connect<TResult = unknown>(path: string, options?: VoiceConnectionOptions): {
+        assistantAudio: import("@angular/core").Signal<{
+            chunk: Uint8Array;
+            format: import("..").AudioFormat;
+            receivedAt: number;
+            turnId?: string;
+        }[]>;
         assistantTexts: import("@angular/core").Signal<string[]>;
         close: () => void;
         endTurn: () => void;

package/dist/audioConditioning.d.ts

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

package/dist/client/actions.d.ts

@@ -1,48 +1,91 @@
 import type { VoiceServerMessage } from '../types';
 export declare const serverMessageToAction: <TResult = unknown>(message: VoiceServerMessage<TResult>) => {
+    chunk: Uint8Array<ArrayBuffer>;
+    format: import("..").AudioFormat;
+    receivedAt: number;
+    turnId: string | undefined;
+    type: "audio";
+    text?: undefined;
+    sessionId?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    scenarioId?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
     text: string;
     type: "assistant";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     sessionId?: undefined;
     message?: undefined;
     transcript?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
     type: "complete";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     message?: undefined;
     transcript?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
     turn?: undefined;
 } | {
     message: string;
     type: "error";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
     transcript?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
     type: "final";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
     message?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
     type: "partial";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
     message?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
+    scenarioId: string | undefined;
     status: import("..").VoiceSessionStatus;
     type: "session";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     message?: undefined;
     transcript?: undefined;
@@ -50,9 +93,14 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
 } | {
     turn: import("..").VoiceTurnRecord<TResult>;
     type: "turn";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
     message?: undefined;
     transcript?: undefined;
+    scenarioId?: undefined;
     status?: undefined;
 } | null;

package/dist/client/audioPlayer.d.ts

@@ -0,0 +1,40 @@
+import type { AudioFormat, VoiceAudioPlayer, VoiceAudioPlayerOptions, VoiceAudioPlayerSource } from '../types';
+type MinimalAudioBuffer = {
+    duration: number;
+    getChannelData: (channel: number) => Float32Array;
+};
+type MinimalAudioBufferSourceNode = {
+    buffer: MinimalAudioBuffer | null;
+    connect: (destination: unknown) => void;
+    disconnect?: () => void;
+    onended: (() => void) | null;
+    start: (when?: number) => void;
+    stop?: () => void;
+};
+type MinimalGainNode = {
+    connect?: (destination: unknown) => void;
+    disconnect?: () => void;
+    gain: {
+        setValueAtTime?: (value: number, time: number) => void;
+        value: number;
+    };
+};
+type MinimalAudioContext = {
+    baseLatency?: number;
+    close: () => Promise<void>;
+    createBuffer: (numberOfChannels: number, length: number, sampleRate: number) => MinimalAudioBuffer;
+    createBufferSource: () => MinimalAudioBufferSourceNode;
+    createGain?: () => MinimalGainNode;
+    currentTime: number;
+    destination: unknown;
+    outputLatency?: number;
+    resume: () => Promise<void>;
+    state: 'closed' | 'running' | 'suspended';
+    suspend: () => Promise<void>;
+};
+export declare const createVoiceAudioPlayer: (source: VoiceAudioPlayerSource, options?: VoiceAudioPlayerOptions) => VoiceAudioPlayer;
+export declare const decodeVoiceAudioChunk: (audioContext: Pick<MinimalAudioContext, "createBuffer">, chunk: {
+    chunk: Uint8Array;
+    format: AudioFormat;
+}) => MinimalAudioBuffer;
+export {};

package/dist/client/connection.d.ts

@@ -1,8 +1,13 @@
 import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
 type VoiceConnectionHandle = {
+    start: (input?: {
+        sessionId?: string;
+        scenarioId?: string;
+    }) => void;
     close: () => void;
     endTurn: () => void;
     getReadyState: () => number;
+    getScenarioId: () => string;
     getSessionId: () => string;
     send: (message: VoiceClientMessage) => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;

package/dist/client/controller.d.ts

@@ -0,0 +1,2 @@
+import type { VoiceController, VoiceControllerOptions } from '../types';
+export declare const createVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => VoiceController<TResult>;

package/dist/client/duplex.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceAudioPlayer, VoiceBargeInBinding, VoiceBargeInOptions, VoiceController, VoiceDuplexController, VoiceDuplexControllerOptions } from '../types';
+export declare const bindVoiceBargeIn: <TResult = unknown>(controller: Pick<VoiceController<TResult>, "partial" | "sendAudio" | "subscribe">, player: Pick<VoiceAudioPlayer, "interrupt" | "isPlaying">, options?: VoiceBargeInOptions) => VoiceBargeInBinding;
+export declare const createVoiceDuplexController: <TResult = unknown>(path: string, options?: VoiceDuplexControllerOptions) => VoiceDuplexController<TResult>;