@ariaflowagents/livekit-plugin-transport-sip 0.9.10 → 0.9.12

package/dist/audio_input.d.ts

@@ -2,10 +2,12 @@ import { AudioInput } from '@ariaflowagents/livekit-plugin';
 import type { RtpSession } from './rtp/rtp_session.js';
 /**
  * Receives audio from an RTP stream and provides it as a
- * ReadableStream<AudioFrame> for the STT pipeline.
+ * ReadableStream<AudioFrame> for the voice pipeline.
  *
- * RTP delivers G.711 at 8kHz. After decode, we upsample to 16kHz
- * to match GeminiLiveSTT's default sample rate expectation.
+ * RTP delivers G.711 at 8kHz. After decode, we upsample to the
+ * configured output sample rate (default 24kHz, matching Twilio and
+ * other transports). Cascaded callers can pass 16kHz for
+ * GeminiLiveSTT backward compatibility.
  *
  * The resampler is allocated once and reused across all frames
  * for the lifetime of this input (Sox sinc via local Rust FFI).
@@ -16,9 +18,8 @@ export declare class SIPAudioInput extends AudioInput {
     private closed;
     private numChannels;
     private resampler;
-    constructor(rtpSession: RtpSession, sampleRate?: number, numChannels?: number);
+    constructor(rtpSession: RtpSession, sampleRate?: number, numChannels?: number, outputSampleRate?: number);
     private startStream;
     private setupListener;
     close(): Promise<void>;
 }
-//# sourceMappingURL=audio_input.d.ts.map

package/dist/audio_input.js

@@ -2,13 +2,15 @@ import { AudioInput, AudioFrame } from '@ariaflowagents/livekit-plugin';
 import { createResampler } from '@ariaflowagents/livekit-plugin/utils/resample';
 import { TransformStream } from 'node:stream/web';
 const RTP_SAMPLE_RATE = 8000;
-const STT_SAMPLE_RATE = 16000;
+const DEFAULT_OUTPUT_SAMPLE_RATE = 24000;
 /**
  * Receives audio from an RTP stream and provides it as a
- * ReadableStream<AudioFrame> for the STT pipeline.
+ * ReadableStream<AudioFrame> for the voice pipeline.
  *
- * RTP delivers G.711 at 8kHz. After decode, we upsample to 16kHz
- * to match GeminiLiveSTT's default sample rate expectation.
+ * RTP delivers G.711 at 8kHz. After decode, we upsample to the
+ * configured output sample rate (default 24kHz, matching Twilio and
+ * other transports). Cascaded callers can pass 16kHz for
+ * GeminiLiveSTT backward compatibility.
  *
  * The resampler is allocated once and reused across all frames
  * for the lifetime of this input (Sox sinc via local Rust FFI).
@@ -18,12 +20,13 @@ export class SIPAudioInput extends AudioInput {
     writer = null;
     closed = false;
     numChannels;
-    resampler = createResampler(RTP_SAMPLE_RATE, STT_SAMPLE_RATE);
-    constructor(rtpSession, sampleRate = RTP_SAMPLE_RATE, numChannels = 1) {
+    resampler;
+    constructor(rtpSession, sampleRate = RTP_SAMPLE_RATE, numChannels = 1, outputSampleRate = DEFAULT_OUTPUT_SAMPLE_RATE) {
         super();
         this.rtpSession = rtpSession;
         void sampleRate;
         this.numChannels = numChannels;
+        this.resampler = createResampler(RTP_SAMPLE_RATE, outputSampleRate);
         this.startStream();
         this.setupListener();
     }
@@ -55,4 +58,3 @@ export class SIPAudioInput extends AudioInput {
         await super.close();
     }
 }
-//# sourceMappingURL=audio_input.js.map

package/dist/audio_output.d.ts

@@ -31,4 +31,3 @@ export declare class SIPAudioOutput extends AudioOutput {
     clearBuffer(): void;
     close(): Promise<void>;
 }
-//# sourceMappingURL=audio_output.d.ts.map

package/dist/audio_output.js

@@ -130,4 +130,3 @@ export class SIPAudioOutput extends AudioOutput {
         this.sendQueue = [];
     }
 }
-//# sourceMappingURL=audio_output.js.map

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { SIPAgentServer } from './server.js';
+export type { SIPNativeSessionOptions, SIPRealtimeSessionOptions, SIPAgentEventSink, } from './server.js';
 export { SIPSignaling } from './sip_signaling.js';
 export type { SIPServerOptions, SIPTransport } from './types.js';
 export { SIPTransportAdapter } from './transport_adapter.js';
@@ -10,4 +11,3 @@ export { RtpSession, type RtpSessionOptions } from './rtp/rtp_session.js';
 export { parseRtpPacket, buildRtpPacket, type RtpPacket } from './rtp/rtp_packet.js';
 export { JitterBuffer } from './rtp/jitter_buffer.js';
 export { createSipNativeAudioTransport } from './native_bridge.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -9,4 +9,3 @@ export { RtpSession } from './rtp/rtp_session.js';
 export { parseRtpPacket, buildRtpPacket } from './rtp/rtp_packet.js';
 export { JitterBuffer } from './rtp/jitter_buffer.js';
 export { createSipNativeAudioTransport } from './native_bridge.js';
-//# sourceMappingURL=index.js.map

package/dist/native_bridge.d.ts

@@ -9,4 +9,3 @@ export declare function createSipNativeAudioTransport(rtpSession: RtpSession, op
     codecSampleRate?: number;
     packetDurationMs?: number;
 }): NativeAudioTransport;
-//# sourceMappingURL=native_bridge.d.ts.map

package/dist/native_bridge.js

@@ -127,4 +127,3 @@ export function createSipNativeAudioTransport(rtpSession, options) {
         },
     };
 }
-//# sourceMappingURL=native_bridge.js.map

package/dist/rtp/jitter_buffer.d.ts

@@ -16,4 +16,3 @@ export declare class JitterBuffer {
     pull(): RtpPacket | null;
     private isOlder;
 }
-//# sourceMappingURL=jitter_buffer.d.ts.map

package/dist/rtp/jitter_buffer.js

@@ -48,4 +48,3 @@ export class JitterBuffer {
         return diff > 0 && diff < 0x8000;
     }
 }
-//# sourceMappingURL=jitter_buffer.js.map

package/dist/rtp/rtp_packet.d.ts

@@ -20,4 +20,3 @@ export interface RtpPacket {
 }
 export declare function parseRtpPacket(data: Buffer): RtpPacket | null;
 export declare function buildRtpPacket(payloadType: number, sequenceNumber: number, timestamp: number, ssrc: number, payload: Uint8Array, marker?: boolean): Buffer;
-//# sourceMappingURL=rtp_packet.d.ts.map

package/dist/rtp/rtp_packet.js

@@ -60,4 +60,3 @@ export function buildRtpPacket(payloadType, sequenceNumber, timestamp, ssrc, pay
     header.writeUInt32BE(ssrc >>> 0, 8);
     return Buffer.concat([header, Buffer.from(payload)]);
 }
-//# sourceMappingURL=rtp_packet.js.map

package/dist/rtp/rtp_session.d.ts

@@ -51,4 +51,3 @@ export declare class RtpSession extends EventEmitter {
     sendAudio(pcm: Int16Array): void;
     close(): void;
 }
-//# sourceMappingURL=rtp_session.d.ts.map

package/dist/rtp/rtp_session.js

@@ -159,4 +159,3 @@ function concatInt16(a, b) {
     out.set(b, a.length);
     return out;
 }
-//# sourceMappingURL=rtp_session.js.map

package/dist/sdp_g711.d.ts

@@ -15,4 +15,3 @@ export declare function negotiateG711FromRemoteOffer(remoteSdp: string, fallback
  * SDP answer body advertising a single negotiated G.711 codec (RFC 3264).
  */
 export declare function buildG711SdpAnswer(localAddress: string, rtpPort: number, codec: Codec): string;
-//# sourceMappingURL=sdp_g711.d.ts.map

package/dist/sdp_g711.js

@@ -71,4 +71,3 @@ export function buildG711SdpAnswer(localAddress, rtpPort, codec) {
         `a=ptime:20\r\n` +
         `a=sendrecv\r\n`);
 }
-//# sourceMappingURL=sdp_g711.js.map

package/dist/server.d.ts

@@ -8,27 +8,79 @@
  * - Works with PBX systems and SIP gateways
  * - G.711 codec negotiation
  *
+ * Supports three session modes:
+ * - Cascaded: startSession() — STT → LLM → TTS pipeline
+ * - Native:   startNativeSession() — RealtimeRuntime + RealtimeAudioClient
+ * - Realtime: startRealtimeSession() — LiveKit AgentSession + provider RealtimeModel
+ *
  * For WebSocket/WebRTC SIP signaling, use
  * `@ariaflow/livekit-plugin-transport-sip-jssip`.
  */
 import { SessionManager, type AriaFlowVoiceSession } from '@ariaflowagents/livekit-plugin';
-import type { voice } from '@livekit/agents';
+import { voice } from '@livekit/agents';
+import type { RealtimeRuntime, RealtimeAudioClient, RealtimeSessionHandle } from '@ariaflowagents/core/realtime';
 import { SIPTransportAdapter } from './transport_adapter.js';
 import type { SIPServerOptions } from './types.js';
+/**
+ * Optional event sink for AgentSession events in realtime mode.
+ * SIP has no text channel — use this callback for observability.
+ */
+export type SIPAgentEventSink = (event: {
+    type: string;
+    callId: string;
+    timestamp: number;
+    data: unknown;
+}) => void;
+/**
+ * Options for starting a native audio session through RealtimeRuntime.
+ */
+export interface SIPNativeSessionOptions {
+    runtime: RealtimeRuntime;
+    createModelClient: () => RealtimeAudioClient;
+    sessionId?: string;
+    userId?: string;
+    agentId?: string;
+}
+/**
+ * Options for starting a direct AgentSession backed by a LiveKit realtime LLM.
+ */
+export interface SIPRealtimeSessionOptions {
+    model: NonNullable<voice.AgentSessionOptions['llm']>;
+    agent: voice.Agent;
+    maxToolSteps?: number;
+    sessionId?: string;
+    onSessionEnd?: (reason: string) => void;
+    onEvent?: SIPAgentEventSink;
+}
 /**
  * A SIP server that accepts incoming calls and creates agent sessions.
  *
- * This server handles SIP signaling (via UDP or WebSocket) and manages
- * RTP sessions for audio transmission.
+ * Supports three session modes:
  *
- * UDP Example:
- *   const server = new SIPAgentServer({
- *     transport: 'udp',
- *     localAddress: '10.0.0.5',
- *     sipPort: 5060,
- *     rtpPortStart: 10000,
+ * **Cascaded** (startSession):
+ *   server.onCall(async (transport, callId) => {
+ *     const voiceSession = new AriaFlowVoiceSession({ runtime, stt, tts });
+ *     await server.startSession(callId, voiceSession);
  *   });
  *
+ * **Native** (startNativeSession):
+ *   server.onCall(async (transport, callId) => {
+ *     await server.startNativeSession(callId, {
+ *       runtime: realtimeRuntime,
+ *       createModelClient: () => new GeminiLiveSession({ apiKey, model }),
+ *     });
+ *   });
+ *
+ * **Realtime** (startRealtimeSession):
+ *   server.onCall(async (transport, callId) => {
+ *     const binding = await createAriaFlowRealtimeAgent({ authority, agentId });
+ *     const session = await server.startRealtimeSession(callId, {
+ *       model: new google.beta.realtime.RealtimeModel({ apiKey }),
+ *       agent: binding.agent,
+ *       onSessionEnd: (reason) => binding.controller.detach(reason),
+ *     });
+ *     binding.controller.attach(session);
+ *   });
  */
 export declare class SIPAgentServer {
     private options;
@@ -39,9 +91,30 @@ export declare class SIPAgentServer {
     private activeTransports;
     private transportType;
     private activeVoiceSessions;
+    private nativeSessions;
+    private realtimeSessions;
     constructor(options: SIPServerOptions);
     onCall(handler: (adapter: SIPTransportAdapter, callId: string) => void | Promise<void>): void;
+    /**
+     * Start a cascaded voice session (STT → LLM → TTS).
+     */
     startSession(callId: string, voiceSession: AriaFlowVoiceSession): Promise<voice.AgentSession>;
+    /**
+     * Start a native audio session that routes audio directly through
+     * RealtimeRuntime (e.g., Gemini Live, OpenAI Realtime).
+     *
+     * Uses the SIP native audio bridge to convert RTP 8kHz ↔ 24kHz PCM
+     * for the realtime model client.
+     */
+    startNativeSession(callId: string, options: SIPNativeSessionOptions): Promise<RealtimeSessionHandle>;
+    /**
+     * Start a direct LiveKit AgentSession over the SIP transport.
+     *
+     * This path is for native realtime models such as
+     * @livekit/agents-plugin-google's RealtimeModel. It wires the transport's
+     * AudioInput/AudioOutput/TextOutput directly into AgentSession.
+     */
+    startRealtimeSession(callId: string, options: SIPRealtimeSessionOptions): Promise<voice.AgentSession>;
     /**
      * Allocate a local RTP port and create a transport adapter.
      * This is called internally when a SIP INVITE is received.
@@ -49,11 +122,12 @@ export declare class SIPAgentServer {
     private createTransport;
     /**
      * Start listening for SIP INVITE requests.
-     *
-     * For UDP transport: Binds UDP socket and listens for SIP messages.
-     * For WebSocket transport: Connects to WebSocket server and listens for SIP messages.
      */
     listen(): Promise<void>;
+    /**
+     * Clean up all resources for a call across all three session modes.
+     */
+    private cleanupCall;
     /**
      * Hang up an active call.
      */
@@ -73,4 +147,3 @@ export declare class SIPAgentServer {
     get status(): 'disconnected' | 'connecting' | 'connected';
     close(): Promise<void>;
 }
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -8,13 +8,20 @@
  * - Works with PBX systems and SIP gateways
  * - G.711 codec negotiation
  *
+ * Supports three session modes:
+ * - Cascaded: startSession() — STT → LLM → TTS pipeline
+ * - Native:   startNativeSession() — RealtimeRuntime + RealtimeAudioClient
+ * - Realtime: startRealtimeSession() — LiveKit AgentSession + provider RealtimeModel
+ *
  * For WebSocket/WebRTC SIP signaling, use
  * `@ariaflow/livekit-plugin-transport-sip-jssip`.
  */
 import { SessionManager } from '@ariaflowagents/livekit-plugin';
+import { voice } from '@livekit/agents';
 import { SIPTransportAdapter } from './transport_adapter.js';
 import { RtpSession } from './rtp/rtp_session.js';
 import { SIPSignaling } from './sip_signaling.js';
+import { createSipNativeAudioTransport } from './native_bridge.js';
 /**
  * Parse the remote RTP endpoint from an SDP body.
  * Extracts the connection address (c= line) and audio port (m= line).
@@ -35,17 +42,32 @@ function parseSdpRemoteEndpoint(sdp) {
 /**
  * A SIP server that accepts incoming calls and creates agent sessions.
  *
- * This server handles SIP signaling (via UDP or WebSocket) and manages
- * RTP sessions for audio transmission.
+ * Supports three session modes:
+ *
+ * **Cascaded** (startSession):
+ *   server.onCall(async (transport, callId) => {
+ *     const voiceSession = new AriaFlowVoiceSession({ runtime, stt, tts });
+ *     await server.startSession(callId, voiceSession);
+ *   });
  *
- * UDP Example:
- *   const server = new SIPAgentServer({
- *     transport: 'udp',
- *     localAddress: '10.0.0.5',
- *     sipPort: 5060,
- *     rtpPortStart: 10000,
+ * **Native** (startNativeSession):
+ *   server.onCall(async (transport, callId) => {
+ *     await server.startNativeSession(callId, {
+ *       runtime: realtimeRuntime,
+ *       createModelClient: () => new GeminiLiveSession({ apiKey, model }),
+ *     });
  *   });
  *
+ * **Realtime** (startRealtimeSession):
+ *   server.onCall(async (transport, callId) => {
+ *     const binding = await createAriaFlowRealtimeAgent({ authority, agentId });
+ *     const session = await server.startRealtimeSession(callId, {
+ *       model: new google.beta.realtime.RealtimeModel({ apiKey }),
+ *       agent: binding.agent,
+ *       onSessionEnd: (reason) => binding.controller.detach(reason),
+ *     });
+ *     binding.controller.attach(session);
+ *   });
  */
 export class SIPAgentServer {
     options;
@@ -56,6 +78,8 @@ export class SIPAgentServer {
     activeTransports = new Map();
     transportType;
     activeVoiceSessions = new Map();
+    nativeSessions = new Map();
+    realtimeSessions = new Map();
     constructor(options) {
         this.options = options;
         this.transportType = options.transport ?? 'udp';
@@ -69,6 +93,9 @@ export class SIPAgentServer {
     onCall(handler) {
         this.callHandler = handler;
     }
+    /**
+     * Start a cascaded voice session (STT → LLM → TTS).
+     */
     async startSession(callId, voiceSession) {
         const transport = this.activeTransports.get(callId);
         if (!transport) {
@@ -78,6 +105,123 @@ export class SIPAgentServer {
         this.activeVoiceSessions.set(callId, voiceSession);
         return agentSession;
     }
+    /**
+     * Start a native audio session that routes audio directly through
+     * RealtimeRuntime (e.g., Gemini Live, OpenAI Realtime).
+     *
+     * Uses the SIP native audio bridge to convert RTP 8kHz ↔ 24kHz PCM
+     * for the realtime model client.
+     */
+    async startNativeSession(callId, options) {
+        const adapter = this.activeTransports.get(callId);
+        if (!adapter) {
+            throw new Error(`Transport not found for call: ${callId}`);
+        }
+        const nativeTransport = createSipNativeAudioTransport(adapter.rtpSession);
+        const modelClient = options.createModelClient();
+        let handle;
+        try {
+            handle = await options.runtime.startSession({
+                modelClient,
+                transport: nativeTransport,
+                sessionId: options.sessionId ?? callId,
+                userId: options.userId,
+                agentId: options.agentId,
+            });
+        }
+        catch (err) {
+            nativeTransport.close();
+            throw err;
+        }
+        this.nativeSessions.set(callId, { handle, transport: nativeTransport });
+        console.log(`[SIPAgentServer] native session started for call: ${callId}`);
+        return handle;
+    }
+    /**
+     * Start a direct LiveKit AgentSession over the SIP transport.
+     *
+     * This path is for native realtime models such as
+     * @livekit/agents-plugin-google's RealtimeModel. It wires the transport's
+     * AudioInput/AudioOutput/TextOutput directly into AgentSession.
+     */
+    async startRealtimeSession(callId, options) {
+        const adapter = this.activeTransports.get(callId);
+        if (!adapter) {
+            throw new Error(`Transport not found for call: ${callId}`);
+        }
+        const sessionId = options.sessionId ?? callId;
+        let sessionEnded = false;
+        const session = new voice.AgentSession({
+            llm: options.model,
+            maxToolSteps: options.maxToolSteps,
+        });
+        // Wire I/O directly
+        session.input.audio = adapter.audioInput;
+        session.output.audio = adapter.audioOutput;
+        session.output.transcription = adapter.textOutput;
+        const emitEvent = options.onEvent
+            ? (type, data) => {
+                options.onEvent({ type, callId, timestamp: Date.now(), data });
+            }
+            : undefined;
+        session.on(voice.AgentSessionEventTypes.AgentStateChanged, (event) => {
+            emitEvent?.('agent_state', event.newState);
+        });
+        session.on(voice.AgentSessionEventTypes.UserStateChanged, (event) => {
+            emitEvent?.('user_state', event.newState);
+        });
+        session.on(voice.AgentSessionEventTypes.UserInputTranscribed, (event) => {
+            emitEvent?.('user_transcription', { text: event.transcript, isFinal: event.isFinal });
+        });
+        session.on(voice.AgentSessionEventTypes.FunctionToolsExecuted, (event) => {
+            event.functionCalls.forEach((call, index) => {
+                emitEvent?.('tool_result', {
+                    toolName: call.name,
+                    success: Boolean(event.functionCallOutputs[index]),
+                });
+            });
+        });
+        session.on(voice.AgentSessionEventTypes.MetricsCollected, (event) => {
+            emitEvent?.('metrics_collected', {
+                metricsType: typeof event.metrics?.type === 'string' ? event.metrics.type : undefined,
+            });
+        });
+        session.on(voice.AgentSessionEventTypes.Close, () => {
+            if (sessionEnded)
+                return;
+            sessionEnded = true;
+            this.realtimeSessions.delete(callId);
+            options.onSessionEnd?.('session_close');
+        });
+        session.on(voice.AgentSessionEventTypes.Error, (event) => {
+            const msg = event.error instanceof Error ? event.error.message : String(event.error);
+            console.error(`[SIPAgentServer] realtime session error for ${callId}: ${msg}`);
+            emitEvent?.('error', { message: msg });
+        });
+        const closeRealtimeSession = (reason) => {
+            if (sessionEnded)
+                return;
+            sessionEnded = true;
+            this.realtimeSessions.delete(callId);
+            options.onSessionEnd?.(reason);
+            session.close().catch((err) => {
+                console.error(`[SIPAgentServer] realtime session close error for ${callId}:`, err instanceof Error ? err.message : String(err));
+            });
+        };
+        try {
+            await session.start({ agent: options.agent });
+        }
+        catch (err) {
+            try {
+                await session.close();
+            }
+            catch { /* swallow cleanup errors */ }
+            throw err;
+        }
+        this.realtimeSessions.set(callId, { session, close: closeRealtimeSession });
+        console.log(`[SIPAgentServer] realtime session started for call: ${callId}`);
+        return session;
+    }
     /**
      * Allocate a local RTP port and create a transport adapter.
      * This is called internally when a SIP INVITE is received.
@@ -103,9 +247,6 @@ export class SIPAgentServer {
     }
     /**
      * Start listening for SIP INVITE requests.
-     *
-     * For UDP transport: Binds UDP socket and listens for SIP messages.
-     * For WebSocket transport: Connects to WebSocket server and listens for SIP messages.
      */
     async listen() {
         const transportName = this.transportType === 'websocket' ? 'WebSocket' : 'UDP';
@@ -131,33 +272,50 @@ export class SIPAgentServer {
         }, async (callId) => {
             // Handle BYE from remote party
             console.log(`[SIPAgentServer] Remote party hung up call: ${callId}`);
-            const transport = this.activeTransports.get(callId);
-            if (transport) {
-                await transport.close();
-                this.activeTransports.delete(callId);
-            }
-            const voiceSession = this.activeVoiceSessions.get(callId);
-            if (voiceSession) {
-                await voiceSession.close();
-                this.activeVoiceSessions.delete(callId);
-            }
+            await this.cleanupCall(callId, 'remote_hangup');
         });
         console.log(`[SIPAgentServer] Listening for calls (${transportName})`);
     }
     /**
-     * Hang up an active call.
+     * Clean up all resources for a call across all three session modes.
      */
-    async hangup(callId) {
-        const transport = this.activeTransports.get(callId);
-        if (transport) {
-            await transport.close();
-            this.activeTransports.delete(callId);
-        }
+    async cleanupCall(callId, reason) {
+        // Cascaded cleanup
         const voiceSession = this.activeVoiceSessions.get(callId);
         if (voiceSession) {
-            await voiceSession.close();
             this.activeVoiceSessions.delete(callId);
+            await voiceSession.close().catch((err) => {
+                console.error(`[SIPAgentServer] voice session close error for ${callId}:`, err instanceof Error ? err.message : String(err));
+            });
         }
+        // Native cleanup
+        const nativeEntry = this.nativeSessions.get(callId);
+        if (nativeEntry) {
+            this.nativeSessions.delete(callId);
+            await nativeEntry.handle.stop().catch((err) => {
+                console.error(`[SIPAgentServer] native session stop error for ${callId}:`, err instanceof Error ? err.message : String(err));
+            });
+            nativeEntry.transport.close();
+        }
+        // Realtime cleanup
+        const realtimeEntry = this.realtimeSessions.get(callId);
+        if (realtimeEntry) {
+            realtimeEntry.close(reason);
+        }
+        // Transport cleanup (last — sessions may still be using it)
+        const transport = this.activeTransports.get(callId);
+        if (transport) {
+            this.activeTransports.delete(callId);
+            await transport.close().catch((err) => {
+                console.error(`[SIPAgentServer] transport close error for ${callId}:`, err instanceof Error ? err.message : String(err));
+            });
+        }
+    }
+    /**
+     * Hang up an active call.
+     */
+    async hangup(callId) {
+        await this.cleanupCall(callId, 'local_hangup');
         await this.signaling.hangup(callId);
     }
     get sessions() {
@@ -182,16 +340,27 @@ export class SIPAgentServer {
         return 'connected';
     }
     async close() {
-        // Close all active voice sessions
-        const voiceSessionPromises = Array.from(this.activeVoiceSessions.values()).map((s) => s.close());
+        // Close all cascaded voice sessions
+        const voiceSessionPromises = Array.from(this.activeVoiceSessions.values()).map((s) => s.close().catch(() => { }));
         await Promise.allSettled(voiceSessionPromises);
         this.activeVoiceSessions.clear();
+        // Stop all native sessions
+        const nativeStops = Array.from(this.nativeSessions.values()).map(async (entry) => {
+            await entry.handle.stop().catch(() => { });
+            entry.transport.close();
+        });
+        await Promise.allSettled(nativeStops);
+        this.nativeSessions.clear();
+        // Close all realtime sessions
+        for (const [, entry] of this.realtimeSessions) {
+            entry.close('server_shutdown');
+        }
+        this.realtimeSessions.clear();
         // Close all active transports
-        const closePromises = Array.from(this.activeTransports.values()).map((t) => t.close());
+        const closePromises = Array.from(this.activeTransports.values()).map((t) => t.close().catch(() => { }));
         await Promise.allSettled(closePromises);
         this.activeTransports.clear();
         await this.sessionManager.closeAll();
         await this.signaling.stop();
     }
 }
-//# sourceMappingURL=server.js.map

package/dist/sip_signaling.d.ts

@@ -70,4 +70,3 @@ export declare class SIPSignaling {
     private generateTag;
     private generateBranch;
 }
-//# sourceMappingURL=sip_signaling.d.ts.map

package/dist/sip_signaling.js

@@ -550,4 +550,3 @@ export class SIPSignaling {
         return `z9hG4bK${Math.random().toString(36).slice(2, 12)}`;
     }
 }
-//# sourceMappingURL=sip_signaling.js.map

package/dist/text_output.d.ts

@@ -13,4 +13,3 @@ export declare class SIPTextOutput extends TextOutput {
     captureText(text: string | TimedString): Promise<void>;
     flush(): void;
 }
-//# sourceMappingURL=text_output.d.ts.map

package/dist/text_output.js

@@ -32,4 +32,3 @@ export class SIPTextOutput extends TextOutput {
         }
     }
 }
-//# sourceMappingURL=text_output.js.map

package/dist/transport_adapter.d.ts

@@ -5,18 +5,25 @@ import { SIPTextOutput } from './text_output.js';
 import type { RtpSession } from './rtp/rtp_session.js';
 import type { Codec } from '@ariaflowagents/livekit-plugin/codec/g711';
 export declare class SIPTransportAdapter extends TransportAdapter {
-    private rtpSession;
     readonly id: string;
     readonly audioInput: SIPAudioInput;
     readonly audioOutput: SIPAudioOutput;
     readonly textOutput: SIPTextOutput;
     readonly config: TransportAdapterConfig;
+    private _rtpSession;
     private _isOpen;
     constructor(rtpSession: RtpSession, codec: Codec, options: {
         id: string;
         packetDurationMs?: number;
+        /**
+         * Output sample rate for SIPAudioInput. Default 24kHz (matching
+         * Twilio and all other transports). Pass 16000 for cascaded mode
+         * with GeminiLiveSTT backward compatibility.
+         */
+        outputSampleRate?: number;
     });
+    /** The underlying RTP session (for native bridge access). */
+    get rtpSession(): RtpSession;
     get isOpen(): boolean;
     close(): Promise<void>;
 }
-//# sourceMappingURL=transport_adapter.d.ts.map