@layercode/js-sdk 1.0.11 → 1.0.13

package/dist/types/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Interface for LayercodeClient constructor options
+ */
+interface LayercodeClientOptions {
+    /** The ID of the Layercode pipeline to connect to */
+    pipelineId: string;
+    /** The ID of the session to connect to */
+    sessionId?: string | null;
+    /** The endpoint URL for the audio agent API */
+    authorizeSessionEndpoint: string;
+    /** Metadata to send with webhooks */
+    metadata?: Record<string, any>;
+    /** Enable/disable voice activity detector (VAD) which improves turn taking */
+    vadEnabled?: boolean;
+    /** Callback when connection is established */
+    onConnect?: ({ sessionId }: {
+        sessionId: string | null;
+    }) => void;
+    /** Callback when connection is closed */
+    onDisconnect?: () => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback for data messages */
+    onDataMessage?: (message: any) => void;
+    /** Callback for user audio amplitude changes */
+    onUserAmplitudeChange?: (amplitude: number) => void;
+    /** Callback for agent audio amplitude changes */
+    onAgentAmplitudeChange?: (amplitude: number) => void;
+    /** Callback when connection status changes */
+    onStatusChange?: (status: string) => void;
+}
+/**
+ * @class LayercodeClient
+ * @classdesc Core client for Layercode audio pipeline that manages audio recording, WebSocket communication, and speech processing.
+ */
+declare class LayercodeClient {
+    private options;
+    private wavRecorder;
+    private wavPlayer;
+    private vad;
+    private ws;
+    private AMPLITUDE_MONITORING_SAMPLE_RATE;
+    private pushToTalkActive;
+    private vadPausedPlayer;
+    _websocketUrl: string;
+    status: string;
+    userAudioAmplitude: number;
+    agentAudioAmplitude: number;
+    sessionId: string | null;
+    /**
+     * Creates an instance of LayercodeClient.
+     * @param {Object} options - Configuration options
+     */
+    constructor(options: LayercodeClientOptions);
+    /**
+     * Updates the connection status and triggers the callback
+     * @param {string} status - New status value
+     * @private
+     */
+    private _setStatus;
+    /**
+     * Handles when agent audio finishes playing
+     * @private
+     */
+    private _clientResponseAudioReplayFinished;
+    private _clientInterruptAssistantReplay;
+    triggerUserTurnStarted(): Promise<void>;
+    triggerUserTurnFinished(): Promise<void>;
+    /**
+     * Handles incoming WebSocket messages
+     * @param {MessageEvent} event - The WebSocket message event
+     * @private
+     */
+    private _handleWebSocketMessage;
+    /**
+     * Handles available client browser microphone audio data and sends it over the WebSocket
+     * @param {ArrayBuffer} data - The audio data buffer
+     * @private
+     */
+    private _handleDataAvailable;
+    private _wsSend;
+    /**
+     * Sets up amplitude monitoring for a given audio source.
+     * @param {WavRecorder | WavStreamPlayer} source - The audio source (recorder or player).
+     * @param {(amplitude: number) => void} callback - The callback function to invoke on amplitude change.
+     * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
+     * @private
+     */
+    private _setupAmplitudeMonitoring;
+    /**
+     * Connects to the Layercode pipeline and starts the audio session
+     * @async
+     * @returns {Promise<void>}
+     */
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Gets the microphone MediaStream used by this client
+     * @returns {MediaStream|null} The microphone stream or null if not initialized
+     */
+    getStream(): MediaStream | null;
+}
+export default LayercodeClient;

package/dist/types/interfaces.d.ts

@@ -0,0 +1,36 @@
+export type LayercodeMessageType = 'client.audio' | 'trigger.turn.start' | 'trigger.turn.end' | 'trigger.response.audio.replay_finished' | 'turn.start' | 'turn.end' | 'response.audio' | 'response.data';
+export interface BaseLayercodeMessage {
+    type: LayercodeMessageType;
+    event_id?: string;
+}
+export interface ClientAudioMessage extends BaseLayercodeMessage {
+    type: 'client.audio';
+    content: string;
+}
+export interface ClientTriggerTurnMessage extends BaseLayercodeMessage {
+    type: 'trigger.turn.start' | 'trigger.turn.end';
+    role: 'user';
+}
+export interface ClientTriggerResponseAudioReplayFinishedMessage extends BaseLayercodeMessage {
+    type: 'trigger.response.audio.replay_finished';
+    reason: 'completed' | 'interrupted';
+    last_delta_id_played?: string;
+}
+export interface ServerTurnMessage extends BaseLayercodeMessage {
+    type: 'turn.start' | 'turn.end';
+    role: 'user' | 'assistant';
+}
+export interface ServerResponseAudioMessage extends BaseLayercodeMessage {
+    type: 'response.audio';
+    content: string;
+    delta_id?: string;
+    turn_id: string;
+}
+export interface ServerResponseDataMessage extends BaseLayercodeMessage {
+    type: 'response.data';
+    content: any;
+    turn_id: string;
+}
+export type ServerMessage = ServerTurnMessage | ServerResponseAudioMessage | ServerResponseDataMessage;
+export type ClientMessage = ClientAudioMessage | ClientTriggerTurnMessage | ClientTriggerResponseAudioReplayFinishedMessage;
+export type LayercodeMessage = ClientMessage | ServerMessage;

package/dist/types/wavtools/lib/analysis/audio_analysis.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Output of AudioAnalysis for the frequency domain of the audio
+ * @typedef {Object} AudioAnalysisOutputType
+ * @property {Float32Array} values Amplitude of this frequency between {0, 1} inclusive
+ * @property {number[]} frequencies Raw frequency bucket values
+ * @property {string[]} labels Labels for the frequency bucket values
+ */
+/**
+ * Analyzes audio for visual output
+ * @class
+ */
+export class AudioAnalysis {
+    /**
+     * Retrieves frequency domain data from an AnalyserNode adjusted to a decibel range
+     * returns human-readable formatting and labels
+     * @param {AnalyserNode} analyser
+     * @param {number} sampleRate
+     * @param {Float32Array} [fftResult]
+     * @param {"frequency"|"music"|"voice"} [analysisType]
+     * @param {number} [minDecibels] default -100
+     * @param {number} [maxDecibels] default -30
+     * @returns {AudioAnalysisOutputType}
+     */
+    static getFrequencies(analyser: AnalyserNode, sampleRate: number, fftResult?: Float32Array, analysisType?: "frequency" | "music" | "voice", minDecibels?: number, maxDecibels?: number): AudioAnalysisOutputType;
+    /**
+     * Creates a new AudioAnalysis instance for an HTMLAudioElement
+     * @param {HTMLAudioElement} audioElement
+     * @param {AudioBuffer|null} [audioBuffer] If provided, will cache all frequency domain data from the buffer
+     * @returns {AudioAnalysis}
+     */
+    constructor(audioElement: HTMLAudioElement, audioBuffer?: AudioBuffer | null);
+    fftResults: any[];
+    audio: HTMLAudioElement;
+    context: OfflineAudioContext | AudioContext;
+    analyser: AnalyserNode;
+    sampleRate: number;
+    audioBuffer: AudioBuffer | null;
+    /**
+     * Gets the current frequency domain data from the playing audio track
+     * @param {"frequency"|"music"|"voice"} [analysisType]
+     * @param {number} [minDecibels] default -100
+     * @param {number} [maxDecibels] default -30
+     * @returns {AudioAnalysisOutputType}
+     */
+    getFrequencies(analysisType?: "frequency" | "music" | "voice", minDecibels?: number, maxDecibels?: number): AudioAnalysisOutputType;
+    /**
+     * Resume the internal AudioContext if it was suspended due to the lack of
+     * user interaction when the AudioAnalysis was instantiated.
+     * @returns {Promise<true>}
+     */
+    resumeIfSuspended(): Promise<true>;
+}
+/**
+ * Output of AudioAnalysis for the frequency domain of the audio
+ */
+export type AudioAnalysisOutputType = {
+    /**
+     * Amplitude of this frequency between {0, 1} inclusive
+     */
+    values: Float32Array;
+    /**
+     * Raw frequency bucket values
+     */
+    frequencies: number[];
+    /**
+     * Labels for the frequency bucket values
+     */
+    labels: string[];
+};

package/dist/types/wavtools/lib/analysis/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * All note frequencies from 1st to 8th octave
+ * in format "A#8" (A#, 8th octave)
+ */
+export const noteFrequencies: any[];
+export const noteFrequencyLabels: any[];
+export const voiceFrequencies: any[];
+export const voiceFrequencyLabels: any[];

package/dist/types/wavtools/lib/wav_packer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Raw wav audio file contents
+ * @typedef {Object} WavPackerAudioType
+ * @property {Blob} blob
+ * @property {string} url
+ * @property {number} channelCount
+ * @property {number} sampleRate
+ * @property {number} duration
+ */
+/**
+ * Utility class for assembling PCM16 "audio/wav" data
+ * @class
+ */
+export class WavPacker {
+    /**
+     * Converts Float32Array of amplitude data to ArrayBuffer in Int16Array format
+     * @param {Float32Array} float32Array
+     * @returns {ArrayBuffer}
+     */
+    static floatTo16BitPCM(float32Array: Float32Array): ArrayBuffer;
+    /**
+     * Concatenates two ArrayBuffers
+     * @param {ArrayBuffer} leftBuffer
+     * @param {ArrayBuffer} rightBuffer
+     * @returns {ArrayBuffer}
+     */
+    static mergeBuffers(leftBuffer: ArrayBuffer, rightBuffer: ArrayBuffer): ArrayBuffer;
+    /**
+     * Packs data into an Int16 format
+     * @private
+     * @param {number} size 0 = 1x Int16, 1 = 2x Int16
+     * @param {number} arg value to pack
+     * @returns
+     */
+    private _packData;
+    /**
+     * Packs audio into "audio/wav" Blob
+     * @param {number} sampleRate
+     * @param {{bitsPerSample: number, channels: Array<Float32Array>, data: Int16Array}} audio
+     * @returns {WavPackerAudioType}
+     */
+    pack(sampleRate: number, audio: {
+        bitsPerSample: number;
+        channels: Array<Float32Array>;
+        data: Int16Array;
+    }): WavPackerAudioType;
+}
+/**
+ * Raw wav audio file contents
+ */
+export type WavPackerAudioType = {
+    blob: Blob;
+    url: string;
+    channelCount: number;
+    sampleRate: number;
+    duration: number;
+};

package/package.json

@@ -2,7 +2,7 @@
   "author": "Layercode",
   "license": "MIT",
   "name": "@layercode/js-sdk",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Layercode JavaScript SDK for browser usage",
   "type": "module",
   "main": "dist/layercode-js-sdk.esm.js",
@@ -42,5 +42,9 @@
     "rollup": "^4.0.0",
     "tslib": "^2.5.0",
     "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@ricky0123/vad-web": "^0.0.24",
+    "onnxruntime-web": "^1.21.1"
   }
 }