@eka-care/medassist-core 1.0.65 → 1.0.67

package/dist/esm/voice/VoiceAgent.js

@@ -0,0 +1,305 @@
+import { EventEmitter } from "../internal/events/EventEmitter";
+import { VoiceAudioAnalyser } from "./VoiceAudioAnalyser";
+import { APIError } from "../internal/Error/Error";
+import { VOICE_AGENT_STATE, VOICE_AGENT_EVENTS, } from "./types";
+const DEFAULT_ICE_GATHERING_TIMEOUT_MS = 3000;
+const DEFAULT_SPEAKING_THRESHOLD = 8;
+const ICE_SERVERS_CACHE_TTL_MS = 60 * 60 * 1000; // 60 minutes
+const USER_SILENCE_DEBOUNCE_MS = 600;
+function waitForIceGathering(pc, timeoutMs) {
+    return new Promise((resolve) => {
+        if (pc.iceGatheringState === "complete") {
+            resolve();
+            return;
+        }
+        const timeout = setTimeout(resolve, timeoutMs);
+        pc.onicegatheringstatechange = () => {
+            if (pc.iceGatheringState === "complete") {
+                clearTimeout(timeout);
+                resolve();
+            }
+        };
+    });
+}
+export class VoiceAgent {
+    config;
+    resourceManager;
+    getCredentials;
+    emitter = new EventEmitter();
+    remoteAnalyser = new VoiceAudioAnalyser();
+    localAnalyser = new VoiceAudioAnalyser();
+    pc = null;
+    pcId = null;
+    dataChannel = null;
+    localStream = null;
+    remoteAudio = null;
+    _state = VOICE_AGENT_STATE.IDLE;
+    _isMuted = false;
+    manuallyDisconnected = false;
+    _hasConnectionFailureNotified = false;
+    _userSpeaking = false;
+    _silenceTimer = null;
+    _cachedIceServers = null;
+    _iceServersCachedAt = 0;
+    constructor(config, resourceManager, getCredentials) {
+        this.config = config;
+        this.resourceManager = resourceManager;
+        this.getCredentials = getCredentials;
+    }
+    get state() {
+        return this._state;
+    }
+    get isMuted() {
+        return this._isMuted;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    async connect() {
+        const credentials = await this.getCredentials();
+        this.setState(VOICE_AGENT_STATE.CONNECTING);
+        this._hasConnectionFailureNotified = false;
+        try {
+            if (!navigator.mediaDevices?.getUserMedia) {
+                throw new Error("Microphone access is not available. Please ensure you are using a secure (HTTPS) connection.");
+            }
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    channelCount: 1,
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                    sampleRate: 16000,
+                },
+                video: false,
+            });
+            this.localStream = stream;
+            const iceServers = await this.fetchIceServers(credentials);
+            const pc = new RTCPeerConnection({ iceServers, iceTransportPolicy: "all" });
+            this.pc = pc;
+            // Data channel required by SmallWebRTCTransport — without it the server
+            // connects ICE but drops queued greeting/audio.
+            this.dataChannel = pc.createDataChannel("pipecat-events", { ordered: true });
+            this.dataChannel.onopen = () => console.log("data channel open");
+            this.dataChannel.onclose = () => this.handleConnectionFailure(new Error("Data channel closed"), "Voice connection failed");
+            this.dataChannel.onerror = () => this.handleConnectionFailure(new Error("Data channel error"), "Voice connection failed");
+            stream.getAudioTracks().forEach((track) => pc.addTrack(track, stream));
+            pc.ontrack = (event) => this.handleRemoteTrack(event);
+            pc.onconnectionstatechange = () => {
+                if (pc.connectionState === "connected") {
+                    this.setState(VOICE_AGENT_STATE.LISTENING);
+                    this.startLocalAudioAnalysis(stream);
+                }
+                else if (pc.connectionState === "failed" || pc.connectionState === "closed") {
+                    this.releaseResources();
+                    this.setState(VOICE_AGENT_STATE.IDLE);
+                }
+            };
+            pc.oniceconnectionstatechange = () => {
+                if ((pc.iceConnectionState === "connected" || pc.iceConnectionState === "completed") &&
+                    this._state === VOICE_AGENT_STATE.CONNECTING) {
+                    this.setState(VOICE_AGENT_STATE.LISTENING);
+                    this.startLocalAudioAnalysis(stream);
+                }
+                else if (pc.iceConnectionState === "failed") {
+                    this.releaseResources();
+                    this.setState(VOICE_AGENT_STATE.IDLE);
+                }
+            };
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+            const timeoutMs = this.config.iceGatheringTimeoutMs ?? DEFAULT_ICE_GATHERING_TIMEOUT_MS;
+            await waitForIceGathering(pc, timeoutMs);
+            const buildOfferBody = (creds) => ({
+                sdp: pc.localDescription.sdp,
+                type: pc.localDescription.type,
+                pc_id: this.pcId,
+                request_data: {
+                    session_id: creds.sessionId,
+                    token: creds.sessionToken,
+                },
+            });
+            let answer;
+            try {
+                answer = await this.resourceManager.sendVoiceOffer(buildOfferBody(credentials));
+            }
+            catch (err) {
+                if (err instanceof APIError && err.status === 401 && this.config.handleRefresh) {
+                    await this.config.handleRefresh();
+                    const refreshed = await this.getCredentials();
+                    // If the retry also fails, let it propagate to the outer catch → handleConnectionFailure
+                    answer = await this.resourceManager.sendVoiceOffer(buildOfferBody(refreshed));
+                }
+                else {
+                    throw err;
+                }
+            }
+            if (!answer) {
+                throw new Error("No answer received from voice offer");
+            }
+            this.pcId = answer.pc_id;
+            if (pc.signalingState === "closed")
+                return;
+            await pc.setRemoteDescription(new RTCSessionDescription({ sdp: answer.sdp, type: answer.type }));
+        }
+        catch (err) {
+            this.handleConnectionFailure(err);
+        }
+    }
+    disconnect() {
+        this.manuallyDisconnected = true;
+        this.setState(VOICE_AGENT_STATE.DISCONNECTING);
+        this.releaseResources();
+        this.setState(VOICE_AGENT_STATE.IDLE);
+    }
+    toggleMute() {
+        if (!this.localStream)
+            return;
+        const track = this.localStream.getAudioTracks()[0];
+        if (!track)
+            return;
+        const wasEnabled = track.enabled;
+        this.localStream.getAudioTracks().forEach((t) => { t.enabled = !wasEnabled; });
+        this._isMuted = wasEnabled;
+        this.clearSilenceTimer();
+        this._userSpeaking = false;
+        this.setState(wasEnabled ? VOICE_AGENT_STATE.MUTED : VOICE_AGENT_STATE.LISTENING);
+    }
+    reset() {
+        this.setState(VOICE_AGENT_STATE.IDLE);
+    }
+    destroy() {
+        this.releaseResources();
+        this.emitter.removeAllListeners();
+        this._state = VOICE_AGENT_STATE.IDLE;
+    }
+    // ──────────────────────────── private ────────────────────────────
+    async fetchIceServers(credentials) {
+        if (this.config.iceServers)
+            return this.config.iceServers;
+        const now = Date.now();
+        if (this._cachedIceServers && now - this._iceServersCachedAt < ICE_SERVERS_CACHE_TTL_MS) {
+            return this._cachedIceServers;
+        }
+        let resp;
+        try {
+            resp = await this.resourceManager.getVoiceIceServers(credentials.sessionId, credentials.sessionToken);
+        }
+        catch (err) {
+            if (err instanceof APIError && err.status === 401 && this.config.handleRefresh) {
+                await this.config.handleRefresh();
+                const refreshed = await this.getCredentials();
+                // If the retry also fails, propagate — caller's outer catch → handleConnectionFailure
+                resp = await this.resourceManager.getVoiceIceServers(refreshed.sessionId, refreshed.sessionToken);
+            }
+            else {
+                throw err;
+            }
+        }
+        if (!Array.isArray(resp?.ice_servers) || resp.ice_servers.length === 0) {
+            throw new Error("ICE servers response is empty");
+        }
+        this._cachedIceServers = resp.ice_servers;
+        this._iceServersCachedAt = Date.now();
+        return this._cachedIceServers;
+    }
+    setState(next) {
+        this._state = next;
+        this.emitter.emit(VOICE_AGENT_EVENTS.STATE_CHANGED, next);
+    }
+    clearSilenceTimer() {
+        if (this._silenceTimer !== null) {
+            clearTimeout(this._silenceTimer);
+            this._silenceTimer = null;
+        }
+    }
+    handleConnectionFailure(cause, message = "Voice connection failed") {
+        if (this._hasConnectionFailureNotified)
+            return;
+        if (this._state === VOICE_AGENT_STATE.DISCONNECTING || this.manuallyDisconnected)
+            return;
+        this._hasConnectionFailureNotified = true;
+        console.error("voice connection failure", cause);
+        this.releaseResources();
+        this.setState(VOICE_AGENT_STATE.ERROR);
+        const voiceError = { message, cause };
+        this.emitter.emit(VOICE_AGENT_EVENTS.ERROR, voiceError);
+    }
+    releaseResources() {
+        this.remoteAnalyser.stop();
+        this.localAnalyser.stop();
+        this.clearSilenceTimer();
+        this._userSpeaking = false;
+        if (this.localStream) {
+            this.localStream.getTracks().forEach((t) => t.stop());
+            this.localStream = null;
+        }
+        if (this.dataChannel) {
+            this.dataChannel.close();
+            this.dataChannel = null;
+        }
+        if (this.pc) {
+            this.pc.onconnectionstatechange = null;
+            this.pc.oniceconnectionstatechange = null;
+            this.pc.ontrack = null;
+            this.pc.onicecandidate = null;
+            this.pc.ondatachannel = null;
+            this.pc.close();
+            this.pc = null;
+        }
+        this.pcId = null;
+        this._isMuted = false;
+        if (this.remoteAudio) {
+            this.remoteAudio.srcObject = null;
+        }
+    }
+    startLocalAudioAnalysis(stream) {
+        const threshold = this.config.speakingThreshold ?? DEFAULT_SPEAKING_THRESHOLD;
+        this.localAnalyser.start(stream, threshold, (isUserSpeaking) => {
+            if (this._state !== VOICE_AGENT_STATE.LISTENING &&
+                this._state !== VOICE_AGENT_STATE.THINKING) {
+                return;
+            }
+            if (isUserSpeaking) {
+                this._userSpeaking = true;
+                this.clearSilenceTimer();
+                if (this._state === VOICE_AGENT_STATE.THINKING) {
+                    this.setState(VOICE_AGENT_STATE.LISTENING);
+                }
+            }
+            else if (this._userSpeaking && this._silenceTimer === null) {
+                this._silenceTimer = setTimeout(() => {
+                    this._silenceTimer = null;
+                    if (this._userSpeaking && this._state === VOICE_AGENT_STATE.LISTENING) {
+                        this._userSpeaking = false;
+                        this.setState(VOICE_AGENT_STATE.THINKING);
+                    }
+                }, USER_SILENCE_DEBOUNCE_MS);
+            }
+        });
+    }
+    handleRemoteTrack(event) {
+        if (!this.remoteAudio) {
+            this.remoteAudio = new Audio();
+            this.remoteAudio.autoplay = true;
+        }
+        const remoteStream = event.streams[0];
+        this.remoteAudio.srcObject = remoteStream;
+        const threshold = this.config.speakingThreshold ?? DEFAULT_SPEAKING_THRESHOLD;
+        this.remoteAnalyser.start(remoteStream, threshold, (isSpeaking) => {
+            if (isSpeaking) {
+                this.clearSilenceTimer();
+                this._userSpeaking = false;
+                if (this._state !== VOICE_AGENT_STATE.SPEAKING) {
+                    this.setState(VOICE_AGENT_STATE.SPEAKING);
+                }
+            }
+            else if (this._state === VOICE_AGENT_STATE.SPEAKING) {
+                this.setState(VOICE_AGENT_STATE.LISTENING);
+            }
+        });
+    }
+}

package/dist/esm/voice/VoiceAudioAnalyser.js

@@ -0,0 +1,32 @@
+const DEFAULT_FFT_SIZE = 256;
+export class VoiceAudioAnalyser {
+    audioCtx = null;
+    animFrame = null;
+    start(stream, threshold, onSpeakingChange) {
+        const audioCtx = new AudioContext();
+        this.audioCtx = audioCtx;
+        const analyser = audioCtx.createAnalyser();
+        analyser.fftSize = DEFAULT_FFT_SIZE;
+        audioCtx.createMediaStreamSource(stream).connect(analyser);
+        const data = new Uint8Array(analyser.frequencyBinCount);
+        const poll = () => {
+            if (!this.audioCtx)
+                return;
+            analyser.getByteFrequencyData(data);
+            const avg = data.reduce((s, v) => s + v, 0) / data.length;
+            onSpeakingChange(avg > threshold);
+            this.animFrame = requestAnimationFrame(poll);
+        };
+        poll();
+    }
+    stop() {
+        if (this.animFrame !== null) {
+            cancelAnimationFrame(this.animFrame);
+            this.animFrame = null;
+        }
+        if (this.audioCtx) {
+            this.audioCtx.close().catch(() => { });
+            this.audioCtx = null;
+        }
+    }
+}

package/dist/esm/voice/index.js

@@ -0,0 +1 @@
+export * from "./types";

package/dist/esm/voice/types.js

@@ -0,0 +1,15 @@
+export const VOICE_AGENT_STATE = {
+    IDLE: "idle",
+    CONNECTING: "connecting",
+    CONNECTED: "connected",
+    LISTENING: "listening",
+    THINKING: "thinking",
+    SPEAKING: "speaking",
+    MUTED: "muted",
+    DISCONNECTING: "disconnecting",
+    ERROR: "error",
+};
+export const VOICE_AGENT_EVENTS = {
+    STATE_CHANGED: "voice:state_changed",
+    ERROR: "voice:error",
+};

package/dist/events/Events.d.ts

@@ -43,4 +43,3 @@ export type OutgoingSocketStreamMessage = Outgoing.StreamSynapseToMatrixMessage;
 export type OutgoingSocketEndOfStreamMessage = Outgoing.EndOfStreamSynapseToMatrixMessage;
 export type OutgoingSocket = Outgoing.PingMessage;
 export declare function IsValidSocketMesssage(message: any): message is IncomingSocketMessage;
-//# sourceMappingURL=Events.d.ts.map

package/dist/events/Incoming.d.ts

@@ -1,2 +1 @@
 export type { PingMessage, PongMessage, ErrorMessage, SyncMessage, ConnectionEstablishedMatrixToSynapseMessage, ChatMatrixToSynapseMessage, StreamMatrixToSynapseMessage, EndOfStreamMatrixToSynapseMessage, } from "./types";
-//# sourceMappingURL=Incoming.d.ts.map

package/dist/events/Outgoing.d.ts

@@ -1,2 +1 @@
 export type { PingMessage, PongMessage, ErrorMessage, SyncMessage, AuthSynapseToMatrixMessage, ChatSynapseToMatrixMessage, StreamSynapseToMatrixMessage, EndOfStreamSynapseToMatrixMessage, } from "./types";
-//# sourceMappingURL=Outgoing.d.ts.map

package/dist/events/index.d.ts

@@ -1,3 +1,2 @@
 export * as Outgoing from "../events/Outgoing";
 export * as Incoming from "../events/Incoming";
-//# sourceMappingURL=index.d.ts.map

package/dist/events/types.d.ts

@@ -96,4 +96,3 @@ export interface EndOfStreamMatrixToSynapseMessage extends BaseMessage {
     ev: (typeof SOCKET_EVENTS)["END_OF_STREAM"];
     ct: (typeof SOCKET_CONTENT_TYPES)["TEXT"];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/index.d.ts

@@ -31,4 +31,3 @@ export type { SendMessageOptions, TSynapseError } from "./types";
 export { SYNAPSE_MESSAGE_TYPES } from "./messages/types";
 export * from "./conversation";
 export * from "./voice";
-//# sourceMappingURL=index.d.ts.map

package/dist/internal/Api/BaseResource.d.ts

@@ -32,4 +32,3 @@ export declare abstract class BaseResource {
      */
     protected buildPath(template: string, params: Record<string, string>): string;
 }
-//# sourceMappingURL=BaseResource.d.ts.map

package/dist/internal/Api/HttpClient.d.ts

@@ -22,4 +22,3 @@ export declare class HttpClient {
     private buildUrl;
     private handleError;
 }
-//# sourceMappingURL=HttpClient.d.ts.map

package/dist/internal/Api/types.d.ts

@@ -4,4 +4,3 @@ export interface RequestOptions {
     params?: Record<string, string>;
     retries?: number;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/internal/Error/Error.d.ts

@@ -99,4 +99,3 @@ export declare class ValidationError extends SynapseError {
 type SynapseErrorCtor<T extends SynapseError> = new (message: string, options?: SynapseErrorOptions) => T;
 export declare function normalizeError<T extends SynapseError>(error: unknown, ctor: SynapseErrorCtor<T>, fallbackMessage: string, options?: SynapseErrorOptions): T;
 export {};
-//# sourceMappingURL=Error.d.ts.map

package/dist/internal/Error/types.d.ts

@@ -14,4 +14,3 @@ export interface ErrorContext {
     sessionId: string;
     timestamp: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/internal/connection/BaseConnection.d.ts

@@ -97,4 +97,3 @@ export declare abstract class BaseConnection {
      */
     abstract handleConnected(): void;
 }
-//# sourceMappingURL=BaseConnection.d.ts.map

package/dist/internal/connection/types.d.ts

@@ -40,4 +40,3 @@ export type OnMessageCallback = (event: IncomingMessage) => void;
 export type OnStatusChangeCallback = (status: ConnectionStatus) => void;
 export type OnOpenCallback = () => void;
 export type OnErrorCallback = (error: Error) => void;
-//# sourceMappingURL=types.d.ts.map

package/dist/internal/events/EventEmitter.d.ts

@@ -5,4 +5,3 @@ export declare class EventEmitter {
     emit(event: string, ...args: unknown[]): void;
     removeAllListeners(): void;
 }
-//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/internal/store/index.d.ts

@@ -7,4 +7,3 @@ export declare abstract class Storage {
     abstract delete(key: string): void;
     abstract clear(): void;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/media/audio/Audio.copy.d.ts

@@ -41,4 +41,3 @@ export declare class AudioManager {
     cancel(): void;
     destroy(): void;
 }
-//# sourceMappingURL=Audio.copy.d.ts.map

package/dist/media/audio/Audio.d.ts

@@ -33,4 +33,3 @@ export declare class AudioManager {
     cancel(): void;
     destroy(): void;
 }
-//# sourceMappingURL=Audio.d.ts.map

package/dist/media/audio/types.d.ts

@@ -13,4 +13,3 @@ export interface AudioConfig {
 }
 export type AudioDataCallback = (data: AudioMetaData) => void;
 export type AudioErrorCallback = (error: RecordingError) => void;
-//# sourceMappingURL=types.d.ts.map

package/dist/media/file/File.d.ts

@@ -38,4 +38,3 @@ export declare class Filemanager {
      */
     clearPendingFilesState(): void;
 }
-//# sourceMappingURL=File.d.ts.map

package/dist/messages/MessageManager.d.ts

@@ -9,7 +9,9 @@ export declare class MessageManager {
     private callbacks;
     private fileManager;
     private audioManager;
-    constructor(connection: BaseConnection, callbacks?: SynapseSDKCallbacks);
+    private outgoingBuffer;
+    constructor(callbacks?: SynapseSDKCallbacks);
+    setConnection(connection: BaseConnection): void;
     /**
      * Handle file upload process
      */
@@ -59,6 +61,7 @@ export declare class MessageManager {
      */
     sendSocketPongMessage(): void;
     handleConnectionEstablished(): void;
+    private flushOutgoingBuffer;
     /**
      * Cleanup message service
      */
@@ -68,4 +71,3 @@ export declare class MessageManager {
     private toRecordingError;
     private assertConnection;
 }
-//# sourceMappingURL=MessageManager.d.ts.map

package/dist/messages/MessageManager.js

@@ -11,10 +11,13 @@ class MessageManager {
     callbacks = null;
     fileManager = null;
     audioManager = null;
-    constructor(connection, callbacks) {
-        this.connection = connection || null;
+    outgoingBuffer = null;
+    constructor(callbacks) {
         this.callbacks = callbacks || null;
     }
+    setConnection(connection) {
+        this.connection = connection;
+    }
     /**
      * Handle file upload process
      */
@@ -64,7 +67,20 @@ class MessageManager {
      * send chat message through socket
      */
     sendSocketMessage({ message, files, audio, urls, tool_declined, tool_id, tool_result, initial_prompts }) {
-        const connection = this.assertConnection("sendSocketChatMessage");
+        if (!this.connection?.isConnected()) {
+            this.outgoingBuffer = {
+                ...(message !== undefined && { message }),
+                ...(files && { files }),
+                ...(audio && { audio }),
+                ...(urls && { urls }),
+                ...(tool_declined && { tool_declined }),
+                ...(tool_id && { tool_id }),
+                ...(tool_result && { tool_result }),
+                ...(initial_prompts && { initial_prompts }),
+            };
+            return;
+        }
+        const connection = this.connection;
         let outMessage;
         if ((files && files.length > 0) || (urls && urls.length > 0)) {
             if (files && files.length > 3) {
@@ -355,7 +371,6 @@ class MessageManager {
             this.emitError(error);
             throw error;
         }
-        this.assertConnection("startRecording");
         if (!this.audioManager) {
             this.audioManager = new Audio_1.AudioManager();
         }
@@ -406,12 +421,21 @@ class MessageManager {
     handleConnectionEstablished() {
         this.connection?.handleConnected(); //this will call the onConnectionStatusChange callback with connected
         this.connection?.emit(types_1.SYNAPSE_REALTIME_EVENTS.CONNECTED);
-        // this.connection?.handleConnected();
+        this.flushOutgoingBuffer();
+    }
+    flushOutgoingBuffer() {
+        if (!this.connection?.isConnected() || !this.outgoingBuffer)
+            return;
+        const buf = this.outgoingBuffer;
+        this.outgoingBuffer = null;
+        this.sendSocketMessage(buf);
     }
     /**
      * Cleanup message service
      */
     cleanupMessageServerState() {
+        this.outgoingBuffer = null;
+        this.connection = null;
         if (this.fileManager) {
             this.fileManager.clearPendingFilesState();
             this.fileManager = null;

package/dist/messages/types.d.ts

@@ -149,4 +149,3 @@ export type TMediaCard = {
     link?: string;
 };
 export type SynapseContentTypes = SOCKET_CONTENT_TYPES;
-//# sourceMappingURL=types.d.ts.map

package/dist/resources/config/Config.d.ts

@@ -8,4 +8,3 @@ export declare class Config extends BaseResource {
     private basePath;
     retrieve(agentId: string): Promise<AgentConfigResponse>;
 }
-//# sourceMappingURL=Config.d.ts.map

package/dist/resources/feedback/Feedback.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=Feedback.d.ts.map

package/dist/resources/feedback/types.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=types.d.ts.map

package/dist/resources/index.d.ts

@@ -44,4 +44,3 @@ export declare class ResourceManager {
     getVoiceIceServers(sessionId: string, sessionToken: string): Promise<IceServersResponse>;
     sendVoiceOffer(body: VoiceOfferRequest): Promise<VoiceOfferResponse>;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/resources/session/Session.d.ts

@@ -20,4 +20,3 @@ export declare class Session extends BaseResource {
     feedback(sessionId: string, messageId: string, feedback: USER_FEEDBACK, feedback_reason?: string): Promise<void>;
     callTool(sessionId: string, toolId: string, messageId: string, sessionToken: string, toolParams?: Record<string, unknown>): Promise<ToolCallResponse>;
 }
-//# sourceMappingURL=Session.d.ts.map

package/dist/resources/session/types.d.ts

@@ -66,4 +66,3 @@ export declare const USER_FEEDBACK: {
     readonly NONE: "NONE";
 };
 export type USER_FEEDBACK = (typeof USER_FEEDBACK)[keyof typeof USER_FEEDBACK];
-//# sourceMappingURL=types.d.ts.map

package/dist/resources/toolCall/ToolCall.d.ts

@@ -4,4 +4,3 @@ export declare class ToolCall extends BaseResource {
     private basePath;
     callTool(sessionId: string, toolName: string, toolParams?: Record<string, unknown>): Promise<ToolCallResponse>;
 }
-//# sourceMappingURL=ToolCall.d.ts.map

package/dist/resources/toolCall/types.d.ts

@@ -143,4 +143,3 @@ export declare enum SYNAPSE_EICITATION_STATUS {
 }
 export type ToolCallResponse = StreamMatrixToSynapseMessage & ResourceResponse;
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/resources/types.d.ts

@@ -26,4 +26,3 @@ export type ResourceResponse = {
         msg: string;
     };
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/resources/voice/VoiceResource.d.ts

@@ -6,4 +6,3 @@ export declare class VoiceResource extends BaseResource {
     getIceServers(sessionId: string, sessionToken: string): Promise<IceServersResponse>;
     sendOffer(body: VoiceOfferRequest): Promise<VoiceOfferResponse>;
 }
-//# sourceMappingURL=VoiceResource.d.ts.map

package/dist/resources/voice/types.d.ts

@@ -16,4 +16,3 @@ export interface VoiceOfferResponse extends ResourceResponse {
     type: string;
     pc_id: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types/index.d.ts

@@ -75,4 +75,3 @@ export interface ExistingSessionOptions {
     session_id: string;
     session_token: string;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/Error.d.ts

@@ -42,4 +42,3 @@ export declare class ErrorUtils {
         hint?: string;
     };
 }
-//# sourceMappingURL=Error.d.ts.map

package/dist/voice/VoiceAgent.d.ts

@@ -38,4 +38,3 @@ export declare class VoiceAgent {
     private startLocalAudioAnalysis;
     private handleRemoteTrack;
 }
-//# sourceMappingURL=VoiceAgent.d.ts.map

package/dist/voice/VoiceAudioAnalyser.d.ts

@@ -4,4 +4,3 @@ export declare class VoiceAudioAnalyser {
     start(stream: MediaStream, threshold: number, onSpeakingChange: (isSpeaking: boolean) => void): void;
     stop(): void;
 }
-//# sourceMappingURL=VoiceAudioAnalyser.d.ts.map