@applica-software-guru/persona-sdk 0.0.1-preview2 → 0.0.1-preview4

package/dist/src/messages.js

@@ -0,0 +1,73 @@
+function removeEmptyMessages(messages) {
+    return messages.filter((message) => {
+        if (message.finishReason === 'stop') {
+            return message.text !== null && message.text?.trim() !== '';
+        }
+        return true;
+    });
+}
+function parseMessages(messages) {
+    const outputMessages = [];
+    let currentMessage = null;
+    for (const message of messages) {
+        if (message.type === 'reasoning') {
+            if (currentMessage != null) {
+                outputMessages.push(currentMessage);
+                currentMessage = null;
+            }
+            outputMessages.push(message);
+        }
+        else if (message.functionCalls) {
+            if (currentMessage) {
+                outputMessages.push(currentMessage);
+            }
+            outputMessages.push(message);
+            currentMessage = null;
+        }
+        else if (message.functionResponse) {
+            outputMessages[outputMessages.length - 1] = {
+                ...outputMessages[outputMessages.length - 1],
+                functionResponse: message.functionResponse,
+            };
+        }
+        else if (currentMessage &&
+            message.protocol === currentMessage.protocol &&
+            (currentMessage.role === message.role || message.finishReason === 'stop')) {
+            currentMessage.text += message.text;
+        }
+        else {
+            if (currentMessage) {
+                outputMessages.push(currentMessage);
+            }
+            currentMessage = {
+                ...message,
+            };
+        }
+    }
+    if (currentMessage) {
+        outputMessages.push(currentMessage);
+    }
+    return removeEmptyMessages(outputMessages);
+}
+function convertMessage(message) {
+    if (message.role === 'function') {
+        return {
+            id: message.id,
+            role: 'assistant',
+            status: message?.functionResponse === null ? { type: 'running' } : { type: 'complete', reason: 'stop' },
+            content: message.functionCalls?.map((call) => ({
+                type: 'tool-call',
+                toolName: call.name,
+                toolCallId: call.id,
+                args: call.args,
+                result: message.functionResponse?.result,
+            })) ?? [],
+        };
+    }
+    return {
+        id: message.id,
+        role: message.role,
+        content: message.type === 'reasoning' ? [{ type: 'reasoning', text: message.text }] : [{ type: 'text', text: message.text }],
+    };
+}
+export { parseMessages, convertMessage, removeEmptyMessages };

package/dist/src/protocol/base.d.ts

@@ -0,0 +1,23 @@
+import { Message, MessageListenerCallback, PersonaMessage, PersonaProtocol, ProtocolStatus, Session, StatusChangeCallback } from '../types';
+declare abstract class PersonaProtocolBase implements PersonaProtocol {
+    abstract status: ProtocolStatus;
+    abstract session: Session;
+    abstract autostart: boolean;
+    private statusChangeCallbacks;
+    private messageCallbacks;
+    addStatusChangeListener(callback: StatusChangeCallback): void;
+    addMessageListener(callback: MessageListenerCallback): void;
+    syncSession(session: Session): Promise<void>;
+    notifyMessage(message: PersonaMessage): Promise<void>;
+    notifyMessages(messages: PersonaMessage[]): Promise<void>;
+    setSession(session: Session): Promise<void>;
+    setStatus(status: ProtocolStatus): Promise<void>;
+    clearListeners(): void;
+    abstract getName(): string;
+    abstract getPriority(): number;
+    abstract connect(session?: Session): Promise<Session>;
+    abstract disconnect(): Promise<void>;
+    abstract send(message: Message): Promise<void>;
+}
+export { PersonaProtocolBase };
+//# sourceMappingURL=base.d.ts.map

package/dist/src/protocol/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/protocol/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAE5I,uBAAe,mBAAoB,YAAW,eAAe;IAC3D,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,OAAO,CAAC,qBAAqB,CAA8B;IAC3D,OAAO,CAAC,gBAAgB,CAAiC;IAElD,uBAAuB,CAAC,QAAQ,EAAE,oBAAoB;IAItD,kBAAkB,CAAC,QAAQ,EAAE,uBAAuB;IAG9C,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAGrD,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzD,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAG3C,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAStD,cAAc,IAAI,IAAI;IAK7B,QAAQ,CAAC,OAAO,IAAI,MAAM;IAC1B,QAAQ,CAAC,WAAW,IAAI,MAAM;IAC9B,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IACrD,QAAQ,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IACpC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAC/C;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/src/protocol/base.js

@@ -0,0 +1,37 @@
+class PersonaProtocolBase {
+    statusChangeCallbacks = [];
+    messageCallbacks = [];
+    addStatusChangeListener(callback) {
+        this.statusChangeCallbacks.push(callback);
+    }
+    addMessageListener(callback) {
+        this.messageCallbacks.push(callback);
+    }
+    async syncSession(session) {
+        this.session = session;
+    }
+    async notifyMessage(message) {
+        this.messageCallbacks.forEach((callback) => callback(message));
+    }
+    async notifyMessages(messages) {
+        messages.forEach((message) => {
+            this.messageCallbacks.forEach((callback) => callback(message));
+        });
+    }
+    async setSession(session) {
+        this.session = session;
+    }
+    async setStatus(status) {
+        const notify = this.status !== status;
+        this.status = status;
+        if (!notify) {
+            return;
+        }
+        this.statusChangeCallbacks.forEach((callback) => callback(status));
+    }
+    clearListeners() {
+        this.statusChangeCallbacks = [];
+        this.messageCallbacks = [];
+    }
+}
+export { PersonaProtocolBase };

package/dist/src/protocol/index.d.ts

@@ -0,0 +1,5 @@
+export * from './rest';
+export * from './base';
+export * from './websocket';
+export * from './webrtc';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/dist/src/protocol/index.js

@@ -0,0 +1,4 @@
+export * from './rest';
+export * from './base';
+export * from './websocket';
+export * from './webrtc';

package/dist/src/protocol/rest.d.ts

@@ -0,0 +1,22 @@
+import { PersonaProtocolBase } from './base';
+import { Message, Session, ProtocolStatus, PersonaProtocolBaseConfig } from '../types';
+type PersonaRESTProtocolConfig = PersonaProtocolBaseConfig & {
+    apiUrl: string;
+};
+declare class PersonaRESTProtocol extends PersonaProtocolBase {
+    status: ProtocolStatus;
+    autostart: boolean;
+    session: Session;
+    config: PersonaRESTProtocolConfig;
+    notify: boolean;
+    constructor(config: PersonaRESTProtocolConfig);
+    getName(): string;
+    getPriority(): number;
+    connect(session: Session): Promise<Session>;
+    disconnect(): Promise<void>;
+    syncSession(session: Session): Promise<void>;
+    send(message: Message): Promise<void>;
+}
+export { PersonaRESTProtocol };
+export type { PersonaRESTProtocolConfig };
+//# sourceMappingURL=rest.d.ts.map

package/dist/src/protocol/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../../../src/protocol/rest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAmB,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAExG,KAAK,yBAAyB,GAAG,yBAAyB,GAAG;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,cAAM,mBAAoB,SAAQ,mBAAmB;IACnD,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,yBAAyB,CAAC;IAClC,MAAM,EAAE,OAAO,CAAQ;gBAEX,MAAM,EAAE,yBAAyB;IAOtC,OAAO,IAAI,MAAM;IAIjB,WAAW,IAAI,MAAM;IAIf,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAK3C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBnD;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,YAAY,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/src/protocol/rest.js

@@ -0,0 +1,48 @@
+import { PersonaProtocolBase } from './base';
+class PersonaRESTProtocol extends PersonaProtocolBase {
+    status;
+    autostart;
+    session;
+    config;
+    notify = true;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.status = 'disconnected';
+        this.autostart = true;
+    }
+    getName() {
+        return 'rest';
+    }
+    getPriority() {
+        return 0;
+    }
+    async connect(session) {
+        this.setStatus('connected');
+        return session;
+    }
+    async disconnect() {
+        this.setStatus('disconnected');
+        this.session = null;
+    }
+    async syncSession(session) {
+        this.session = session;
+    }
+    async send(message) {
+        const { apiUrl, apiKey, agentId } = this.config;
+        const sessionId = this.session ?? 'new';
+        const input = message;
+        const response = await fetch(`${apiUrl}/agents/${agentId}/sessions/${sessionId}/messages`, {
+            body: JSON.stringify({ userMessage: input }),
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-fox-apikey': apiKey,
+                'x-persona-apikey': apiKey,
+            },
+        });
+        const personaResponse = (await response.json());
+        this.notifyMessages(personaResponse.response.messages);
+    }
+}
+export { PersonaRESTProtocol };

package/dist/src/protocol/webrtc.d.ts

@@ -0,0 +1,56 @@
+import { PersonaProtocolBase } from './base';
+import { Message, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+type AudioAnalysisData = {
+    localAmplitude: number;
+    remoteAmplitude: number;
+};
+type AudioVisualizerCallback = (data: AudioAnalysisData) => void;
+type PersonaWebRTCMessageCallback = (data: MessageEvent) => void;
+type PersonaWebRTCConfig = PersonaProtocolBaseConfig & {
+    webrtcUrl: string;
+    iceServers?: RTCIceServer[];
+};
+declare class PersonaWebRTCClient {
+    private config;
+    private pc;
+    private ws;
+    private localStream;
+    private remoteStream;
+    private audioCtx;
+    private localAnalyser;
+    private remoteAnalyser;
+    private analyzerFrame;
+    private dataChannel;
+    private isConnected;
+    private visualizerCallbacks;
+    private messageCallbacks;
+    constructor(config: PersonaWebRTCConfig);
+    connect(session: Session): Promise<Session>;
+    disconnect(): Promise<void>;
+    addVisualizerCallback(callback: AudioVisualizerCallback): void;
+    addMessageCallback(callback: PersonaWebRTCMessageCallback): void;
+    createDataChannel(label?: string): void;
+    sendMessage(message: string): void;
+    private _startAnalyzers;
+    private _stopAnalyzers;
+}
+type PersonaWebRTCProtocolConfig = PersonaWebRTCConfig & {
+    autostart?: boolean;
+};
+declare class PersonaWebRTCProtocol extends PersonaProtocolBase {
+    status: ProtocolStatus;
+    session: Session;
+    autostart: boolean;
+    config: PersonaWebRTCProtocolConfig;
+    webRTCClient: PersonaWebRTCClient;
+    constructor(config: PersonaWebRTCProtocolConfig);
+    getName(): string;
+    getPriority(): number;
+    syncSession(session: Session): Promise<void>;
+    connect(session?: Session): Promise<Session>;
+    disconnect(): Promise<void>;
+    send(message: Message): Promise<void>;
+}
+export { PersonaWebRTCProtocol };
+export type { PersonaWebRTCProtocolConfig, AudioVisualizerCallback, AudioAnalysisData };
+//# sourceMappingURL=webrtc.d.ts.map

package/dist/src/protocol/webrtc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc.d.ts","sourceRoot":"","sources":["../../../src/protocol/webrtc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAkB,yBAAyB,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEvG,KAAK,iBAAiB,GAAG;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,KAAK,uBAAuB,GAAG,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEjE,KAAK,4BAA4B,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AAEjE,KAAK,mBAAmB,GAAG,yBAAyB,GAAG;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;CAC7B,CAAC;AAEF,cAAM,mBAAmB;IACvB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,EAAE,CAAkC;IAC5C,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,QAAQ,CAA6B;IAE7C,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,WAAW,CAA+B;IAElD,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,mBAAmB,CAAiC;IAC5D,OAAO,CAAC,gBAAgB,CAAsC;gBAElD,MAAM,EAAE,mBAAmB;IAI1B,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IA+G3C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBjC,qBAAqB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAG9D,kBAAkB,CAAC,QAAQ,EAAE,4BAA4B,GAAG,IAAI;IAIhE,iBAAiB,CAAC,KAAK,SAAa,GAAG,IAAI;IAW3C,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAUzC,OAAO,CAAC,eAAe;IAgDvB,OAAO,CAAC,cAAc;CAQvB;AAED,KAAK,2BAA2B,GAAG,mBAAmB,GAAG;IACvD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,cAAM,qBAAsB,SAAQ,mBAAmB;IACrD,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,2BAA2B,CAAC;IACpC,YAAY,EAAE,mBAAmB,CAAC;gBAEtB,MAAM,EAAE,2BAA2B;IAgBxC,OAAO,IAAI,MAAM;IAGjB,WAAW,IAAI,MAAM;IAIf,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5C,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAgB5C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ7C;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,YAAY,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/src/protocol/webrtc.js

@@ -0,0 +1,267 @@
+import { PersonaProtocolBase } from './base';
+class PersonaWebRTCClient {
+    config;
+    pc = null;
+    ws = null;
+    localStream = null;
+    remoteStream = new MediaStream();
+    audioCtx = null;
+    localAnalyser = null;
+    remoteAnalyser = null;
+    analyzerFrame = null;
+    dataChannel = null;
+    isConnected = false;
+    visualizerCallbacks = [];
+    messageCallbacks = [];
+    constructor(config) {
+        this.config = config;
+    }
+    async connect(session) {
+        if (this.isConnected)
+            return;
+        this.isConnected = true;
+        try {
+            this.localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        }
+        catch (err) {
+            this.config.logger?.error('Error accessing microphone:', err);
+            return;
+        }
+        this.pc = new RTCPeerConnection({
+            iceServers: this.config.iceServers || [
+                {
+                    urls: 'stun:34.38.108.251:3478',
+                },
+                {
+                    urls: 'turn:34.38.108.251:3478',
+                    username: 'webrtc',
+                    credential: 'webrtc',
+                },
+            ],
+        });
+        this.localStream.getTracks().forEach((track) => {
+            this.pc.addTrack(track, this.localStream);
+        });
+        this.pc.ontrack = (event) => {
+            event.streams[0].getTracks().forEach((track) => {
+                this.remoteStream.addTrack(track);
+            });
+            if (!this.audioCtx) {
+                this._startAnalyzers();
+            }
+            const remoteAudio = new Audio();
+            remoteAudio.srcObject = this.remoteStream;
+            remoteAudio.play().catch((e) => {
+                this.config.logger?.error('Error playing remote audio:', e);
+            });
+        };
+        this.pc.onicecandidate = (event) => {
+            if (event.candidate && this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({
+                    type: 'CANDIDATE',
+                    src: 'client',
+                    payload: { candidate: event.candidate },
+                }));
+            }
+        };
+        this.pc.ondatachannel = (event) => {
+            const channel = event.channel;
+            channel.onmessage = (msg) => {
+                this.messageCallbacks.forEach((callback) => {
+                    callback(msg);
+                });
+            };
+        };
+        this.ws = new WebSocket(this.config.webrtcUrl || 'wss://persona.applica.guru/api/webrtc');
+        this.ws.onopen = async () => {
+            const offer = await this.pc.createOffer();
+            await this.pc.setLocalDescription(offer);
+            const metadata = {
+                agentId: this.config.agentId,
+                sessionCode: session,
+            };
+            this.config.logger?.debug('Opening connection to WebRTC server: ', metadata);
+            const offerMessage = {
+                type: 'OFFER',
+                src: crypto.randomUUID?.() || 'client_' + Date.now(),
+                payload: {
+                    sdp: {
+                        sdp: offer.sdp,
+                        type: offer.type,
+                    },
+                    connectionId: (Date.now() % 1000000).toString(),
+                    metadata,
+                },
+            };
+            this.ws.send(JSON.stringify(offerMessage));
+        };
+        this.ws.onmessage = async (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type === 'ANSWER') {
+                await this.pc.setRemoteDescription(new RTCSessionDescription(data.payload.sdp));
+            }
+            else if (data.type === 'CANDIDATE') {
+                try {
+                    await this.pc.addIceCandidate(new RTCIceCandidate(data.payload.candidate));
+                }
+                catch (err) {
+                    this.config.logger?.error('Error adding ICE candidate:', err);
+                }
+            }
+        };
+        this.ws.onclose = () => {
+            this._stopAnalyzers();
+        };
+    }
+    async disconnect() {
+        if (!this.isConnected)
+            return;
+        this.isConnected = false;
+        if (this.ws?.readyState === WebSocket.OPEN)
+            this.ws.close();
+        if (this.pc)
+            this.pc.close();
+        if (this.localStream) {
+            this.localStream.getTracks().forEach((track) => track.stop());
+        }
+        this.remoteStream = new MediaStream();
+        if (this.audioCtx) {
+            await this.audioCtx.close();
+            this.audioCtx = null;
+        }
+        this._stopAnalyzers();
+    }
+    addVisualizerCallback(callback) {
+        this.visualizerCallbacks.push(callback);
+    }
+    addMessageCallback(callback) {
+        this.messageCallbacks.push(callback);
+    }
+    createDataChannel(label = 'messages') {
+        if (!this.pc)
+            return;
+        this.dataChannel = this.pc.createDataChannel(label);
+        this.dataChannel.onopen = () => this.config.logger?.info('Data channel opened');
+        this.dataChannel.onmessage = (msg) => {
+            this.messageCallbacks.forEach((callback) => {
+                callback(msg);
+            });
+        };
+    }
+    sendMessage(message) {
+        if (!this.dataChannel) {
+            this.config.logger?.warn('Data channel is not open, cannot send message');
+            return;
+        }
+        this.dataChannel.send(message);
+        this.config.logger?.info('Sent message:', message);
+    }
+    _startAnalyzers() {
+        if (!this.localStream || !this.remoteStream || this.visualizerCallbacks.length === 0) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+        const localSource = this.audioCtx.createMediaStreamSource(this.localStream);
+        const remoteSource = this.audioCtx.createMediaStreamSource(this.remoteStream);
+        this.localAnalyser = this.audioCtx.createAnalyser();
+        this.remoteAnalyser = this.audioCtx.createAnalyser();
+        this.localAnalyser.fftSize = 256;
+        this.remoteAnalyser.fftSize = 256;
+        localSource.connect(this.localAnalyser);
+        remoteSource.connect(this.remoteAnalyser);
+        const loop = () => {
+            if (!this.localAnalyser || !this.remoteAnalyser || this.visualizerCallbacks.length === 0) {
+                return;
+            }
+            const localArray = new Uint8Array(this.localAnalyser.frequencyBinCount);
+            const remoteArray = new Uint8Array(this.remoteAnalyser.frequencyBinCount);
+            this.localAnalyser.getByteFrequencyData(localArray);
+            this.remoteAnalyser.getByteFrequencyData(remoteArray);
+            const localAmp = localArray.reduce((a, b) => a + b, 0) / localArray.length;
+            const remoteAmp = remoteArray.reduce((a, b) => a + b, 0) / remoteArray.length;
+            if (this.visualizerCallbacks.length > 0) {
+                this.visualizerCallbacks.forEach((callback) => {
+                    callback({
+                        localAmplitude: localAmp,
+                        remoteAmplitude: remoteAmp,
+                    });
+                });
+            }
+            this.analyzerFrame = requestAnimationFrame(loop);
+        };
+        this.analyzerFrame = requestAnimationFrame(loop);
+    }
+    _stopAnalyzers() {
+        if (this.analyzerFrame) {
+            cancelAnimationFrame(this.analyzerFrame);
+            this.analyzerFrame = null;
+        }
+        this.localAnalyser = null;
+        this.remoteAnalyser = null;
+    }
+}
+class PersonaWebRTCProtocol extends PersonaProtocolBase {
+    status;
+    session;
+    autostart;
+    config;
+    webRTCClient;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.status = 'disconnected';
+        this.session = null;
+        this.autostart = config?.autostart ?? false;
+        this.webRTCClient = new PersonaWebRTCClient(config);
+        this.webRTCClient.addMessageCallback((msg) => {
+            config.logger?.debug('Received data message:', msg.data);
+            const data = JSON.parse(msg.data);
+            if (data.type === 'message') {
+                this.notifyMessage(data.payload);
+            }
+        });
+    }
+    getName() {
+        return 'webrtc';
+    }
+    getPriority() {
+        return 10;
+    }
+    async syncSession(session) {
+        super.syncSession(session);
+        if (this.status === 'connected') {
+            await this.disconnect();
+            await this.connect(session);
+        }
+    }
+    async connect(session) {
+        if (this.status === 'connected') {
+            return Promise.resolve(this.session);
+        }
+        this.session = session || this.session || 'new';
+        this.setStatus('connecting');
+        this.config.logger?.debug('Connecting to WebRTC with sessionId:', this.session);
+        await this.webRTCClient.connect(this.session);
+        this.setStatus('connected');
+        await this.webRTCClient.createDataChannel();
+        return this.session;
+    }
+    async disconnect() {
+        if (this.status === 'disconnected') {
+            this.config.logger?.warn('Already disconnected');
+            return Promise.resolve();
+        }
+        await this.webRTCClient.disconnect();
+        this.setStatus('disconnected');
+        this.config?.logger?.debug('Disconnected from WebRTC');
+    }
+    send(message) {
+        if (this.status !== 'connected') {
+            return Promise.reject(new Error('Not connected'));
+        }
+        this.webRTCClient.sendMessage(message);
+        return Promise.resolve();
+    }
+}
+export { PersonaWebRTCProtocol };

package/dist/src/protocol/websocket.d.ts

@@ -0,0 +1,22 @@
+import { Message, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+import { PersonaProtocolBase } from './base';
+type PersonaWebSocketProtocolConfig = PersonaProtocolBaseConfig & {
+    webSocketUrl: string;
+};
+declare class PersonaWebSocketProtocol extends PersonaProtocolBase {
+    status: ProtocolStatus;
+    autostart: boolean;
+    session: Session;
+    config: PersonaWebSocketProtocolConfig;
+    webSocket: WebSocket | null;
+    constructor(config: PersonaWebSocketProtocolConfig);
+    getName(): string;
+    getPriority(): number;
+    syncSession(session: Session): Promise<void>;
+    connect(session?: Session): Promise<Session>;
+    disconnect(): Promise<void>;
+    send(message: Message): Promise<void>;
+}
+export { PersonaWebSocketProtocol };
+export type { PersonaWebSocketProtocolConfig };
+//# sourceMappingURL=websocket.d.ts.map

package/dist/src/protocol/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../src/protocol/websocket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkB,yBAAyB,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACvG,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAE7C,KAAK,8BAA8B,GAAG,yBAAyB,GAAG;IAChE,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,cAAM,wBAAyB,SAAQ,mBAAmB;IACxD,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,8BAA8B,CAAC;IACvC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;gBAEhB,MAAM,EAAE,8BAA8B;IAS3C,OAAO,IAAI,MAAM;IAIjB,WAAW,IAAI,MAAM;IAIf,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IASlD,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IA4C5C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ7C;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAC;AACpC,YAAY,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/src/protocol/websocket.js

@@ -0,0 +1,84 @@
+import { PersonaProtocolBase } from './base';
+class PersonaWebSocketProtocol extends PersonaProtocolBase {
+    status;
+    autostart;
+    session;
+    config;
+    webSocket;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.status = 'disconnected';
+        this.autostart = true;
+        this.session = null;
+        this.webSocket = null;
+    }
+    getName() {
+        return 'websocket';
+    }
+    getPriority() {
+        return 1;
+    }
+    async syncSession(session) {
+        this.config.logger?.debug('Syncing session with WebSocket protocol:', session);
+        this.session = session;
+        if (this.webSocket && this.status === 'connected') {
+            this.disconnect();
+            this.connect(session);
+        }
+    }
+    connect(session) {
+        if (this.webSocket !== null && this.status === 'connected') {
+            return Promise.resolve(this.session);
+        }
+        const sid = session || this.session || 'new';
+        this.config.logger?.debug('Connecting to WebSocket with sessionId:', sid);
+        const apiKey = encodeURIComponent(this.config.apiKey);
+        const agentId = this.config.agentId;
+        const webSocketUrl = `${this.config.webSocketUrl}?sessionCode=${sid}&agentId=${agentId}&apiKey=${apiKey}`;
+        this.setStatus('connecting');
+        this.webSocket = new WebSocket(webSocketUrl);
+        this.webSocket.addEventListener('open', () => {
+            this.setStatus('connected');
+        });
+        this.webSocket.addEventListener('message', (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type !== 'message') {
+                return;
+            }
+            const message = data.payload;
+            this.notifyMessage(message?.thought ? { role: 'assistant', type: 'reasoning', text: message.thought } : message);
+        });
+        this.webSocket.addEventListener('close', () => {
+            this.setStatus('disconnected');
+            this.webSocket = null;
+            this.config.logger?.warn('WebSocket connection closed');
+        });
+        this.webSocket.addEventListener('error', (error) => {
+            this.setStatus('disconnected');
+            this.webSocket = null;
+            this.config.logger?.error('WebSocket error', error);
+            // TODO: Implement reconnection logic
+        });
+        return Promise.resolve(sid);
+    }
+    disconnect() {
+        this.config.logger?.debug('Disconnecting WebSocket');
+        if (this.webSocket && this.status === 'connected') {
+            this.webSocket.close();
+            this.setStatus('disconnected');
+            this.webSocket = null;
+        }
+        return Promise.resolve();
+    }
+    send(message) {
+        if (this.webSocket && this.status === 'connected') {
+            this.webSocket.send(JSON.stringify({ type: 'request', payload: message }));
+            return Promise.resolve();
+        }
+        else {
+            return Promise.reject(new Error('WebSocket is not connected'));
+        }
+    }
+}
+export { PersonaWebSocketProtocol };