Traducere automată · Originalul în engleză

API și protocoale

import PocketTTS
let model = try PocketTTSModel.fromBundle(URL(fileURLWithPath: "/path/to/bundle"))
try await model.generateStreaming(text: "Hello world.") { chunk in
    await consume(chunk.samples)
}

Modulul AudioCommon definește protocoalele de model-agnostic și tipurile partajate. Orice model de conformitate poate fi utilizat interschimbabil prin intermediul acestor interfețe.

Prezentare generală a protocolului

┌─────────────────────────────────────────────────────────┐
│                    AudioCommon                          │
│                                                         │
│  AudioChunk          SpeechGenerationModel (TTS)        │
│  AlignedWord         SpeechRecognitionModel (STT)       │
│  SpeechSegment       ForcedAlignmentModel               │
│                      SpeechToSpeechModel                │
│                      VoiceActivityDetectionModel (VAD)   │
│                      TurnCompletionProvider (EOT)       │
│                      SpeakerEmbeddingModel              │
│                      SpeakerDiarizationModel            │
│                      SpeakerExtractionCapable           │
└─────────────────────────────────────────────────────────┘

Mod de vorbireRecunoaștere

Protocolul pentru modelele de vorbire în text.

public protocol SpeechRecognitionModel: AnyObject {
    var inputSampleRate: Int { get }
    func transcribe(audio: [Float], sampleRate: Int, language: String?) -> String
    func transcribeWithLanguage(audio: [Float], sampleRate: Int, language: String?) -> TranscriptionResult
}

Tipuri de formulare: Qwen3ASRModel, WhisperASRModel, ParakeetASRModel, ParakeetStreamingASRModel, OmnilingualASRModel (CoreML), OmnilingualASRMLXModel (MLX)

Mod de vorbire

Protocolul pentru modelele de text-la-discurs.

public protocol SpeechGenerationModel: AnyObject {
    var sampleRate: Int { get }
    func generate(text: String, language: String?) async throws -> [Float]
    func generateStream(text: String, language: String?) -> AsyncThrowingStream<AudioChunk, Error>  // has default impl
}

generateStream() are o implementare implicită care se încheie generate() ca o singură bucată. Modele cu streaming adevărat (de exemplu, Qwen3-TTS) suprascrie.

Tipuri de formulare: Qwen3TTSModel, CosyVoiceTTSModel, VoxCPM2TTSModel, KokoroTTSModel, IndexTTS2TTSModel

IndexTTS2TTSModel adaugă o referință-audio generate supraîncărcare pentru clonarea vocală cu foc zero și folosește IndexTTS2SynthesisOptions pentru controlul vitezei de vorbire și de pauză.

Qwen3-TTS încărcare locală

fromLocal validează fișierele necesare și caracterul complet al punctului de control, apoi derivă dimensiunea modelului, cuantizarea și arhitectura de la config.json. Valoarea opțională configuration este doar o rezervă pentru metadate omise; metadate malefice sau contradictorii aruncă Qwen3TTSLoadingError.invalidConfiguration înainte de alocarea modelului.

public static func fromLocal(
    modelDirectory: URL,
    tokenizerDirectory: URL,
    configuration: Qwen3TTSConfig? = nil,
    wiredMemoryPolicy: Qwen3TTSWiredMemoryPolicy = .none,
    progressHandler: ((Double, String) -> Void)? = nil
) throws -> Qwen3TTSModel

public static func fromPretrained(
    modelId: String = Qwen3TTSModel.defaultModelId,
    tokenizerModelId: String = "Qwen/Qwen3-TTS-Tokenizer-12Hz",
    cacheDir: URL? = nil,
    tokenizerCacheDir: URL? = nil,
    offlineMode: Bool = false,
    wiredMemoryPolicy: Qwen3TTSWiredMemoryPolicy = .pin(fraction: 0.9),
    progressHandler: ((Double, String) -> Void)? = nil
) async throws -> Qwen3TTSModel

Mod de aliniere forţată

Protocolul pentru alinierea la nivelul de timp a marcajelor de caractere.

public protocol ForcedAlignmentModel: AnyObject {
    func align(audio: [Float], text: String, sampleRate: Int, language: String?) -> [AlignedWord]
}

DiscursPentru DiscursModel

Protocolul pentru modelele de dialog între vorbire și vorbire.

public protocol SpeechToSpeechModel: AnyObject {
    var sampleRate: Int { get }
    func respond(userAudio: [Float]) -> [Float]
    func respondStream(userAudio: [Float]) -> AsyncThrowingStream<AudioChunk, Error>
}

Tipuri de formulare: PersonaPlexModel

HibikiTraduce Model

Translator de vorbire-la-discurs. SpeechToSpeechModel deoarece contractul este diferit: intrarea și producția sunt limbi diferite, lungimea de ieșire este variabilă (orientată EOS, plafonată la max(tSrc * 5/2, tSrc + 20) pași 1.0–1.6× durata sursei pe clipuri de tip FLEURS), și există un flux paralel text-token alături de audio. Ghid complet →

public final class HibikiTranslateModel {
    public let cfg: HibikiConfig
    public static var defaultModelId: String { "aufklarer/Hibiki-Zero-3B-MLX-4bit" }
    public static var modelId8bit: String  { "aufklarer/Hibiki-Zero-3B-MLX-8bit" }

    public static func fromPretrained(
        modelId: String = defaultModelId,
        cacheDir: URL? = nil,
        offlineMode: Bool = false,
        progressHandler: ((Double, String) -> Void)? = nil
    ) async throws -> HibikiTranslateModel

    public func warmUp()

    public func translate(
        sourceAudio: [Float],
        sourceLanguage: HibikiSourceLanguage = .fr,
        verbose: Bool = false
    ) -> (audio: [Float], textTokens: [Int32])

    public func translateStream(
        sourceAudio: [Float],
        sourceLanguage: HibikiSourceLanguage = .fr,
        streaming: HibikiStreamingConfig = .default,
        verbose: Bool = false
    ) -> AsyncThrowingStream<AudioChunk, Error>
}

public enum HibikiSourceLanguage: String, CaseIterable, Sendable, Codable {
    case fr, es, pt, de
}

Rata maximă: 24 kHz mono, atât de intrare, cât și de ieșire. Rată de bază: 12,5 Hz (Mimi codec). Limbi sursă: FR / ES / PT / DE. Limbă de țintă: EN. Set HIBIKI_GREEDY=1 la lansarea procesului pentru decodarea argmax deterministic (matches the CI canaries).

Modul de activare vocală

Protocol pentru detectarea activității vocale.

public protocol VoiceActivityDetectionModel: AnyObject {
    var inputSampleRate: Int { get }
    func detectSpeech(audio: [Float], sampleRate: Int) -> [SpeechSegment]
}

Completare de rotire

Protocolul pentru clasatorii finali consultați de StreamingVADProcessor pe fiecare pauza VAD confirmată. A VAD aude doar tăcere; un model de turn-completare ascultă prosodia întregii declaraţii, astfel încât o pauză de sentinţă medie îl face pe agent să aştepte în timp ce o propoziţie terminată primeşte un răspuns imediat. Hărţile către speech-core sc_turn_completion_vtable_t Vezi... Ghid Smart Turn.

public protocol TurnCompletionProvider: AnyObject {
    /// Probability in [0, 1] that the turn is complete, given the audio of the
    /// turn so far (Smart Turn looks at the last 8 s).
    func turnCompleteProbability(audio: [Float], sampleRate: Int) throws -> Float
}

Tipuri de formulare: SmartTurnModel (Smart Turn v3.2)

VorbitorEmbeddingModel

Protocolul pentru introducerea de către vorbitor a extracției.

public protocol SpeakerEmbeddingModel: AnyObject {
    var inputSampleRate: Int { get }
    var embeddingDimension: Int { get }
    func embed(audio: [Float], sampleRate: Int) -> [Float]
}

Tipuri de formulare: WeSpeakerModel

Mod de diagramă

Protocol pentru modele de diarizare difuzor care atribuie etichete difuzor segmente audio.

public protocol SpeakerDiarizationModel: AnyObject {
    var inputSampleRate: Int { get }
    func diarize(audio: [Float], sampleRate: Int) -> [DiarizedSegment]
}

Tipuri de formulare: DiarizationPipeline (Pyannote), SortformerDiarizer

Extragere difuzorCapabil

Protocolul extins de diarizare pentru motoare care suportă extragerea segmentelor unui vorbitor țintă folosind o înglobare de referință. Nu toate motoarele susțin acest lucru (Sortformer este de la un capăt la altul și nu produce înglobări difuzor).

public protocol SpeakerExtractionCapable: SpeakerDiarizationModel {
    func extractSpeaker(audio: [Float], sampleRate: Int, targetEmbedding: [Float]) -> [SpeechSegment]
}

Tipuri de formulare: DiarizationPipeline (Pyannote numai)

Tipuri partajate

AudioChunk

public struct AudioChunk {
    public let samples: [Float]   // PCM samples
    public let sampleRate: Int    // Sample rate (e.g. 24000)
}

Segment de vorbire

public struct SpeechSegment {
    public let startTime: Float   // Start time in seconds
    public let endTime: Float     // End time in seconds
}

Cuvântul aliniat

public struct AlignedWord {
    public let text: String       // The word
    public let startTime: Float   // Start time in seconds
    public let endTime: Float     // End time in seconds
}

Segment diarizat

public struct DiarizedSegment {
    public let startTime: Float   // Start time in seconds
    public let endTime: Float     // End time in seconds
    public let speakerId: Int     // Speaker identifier (0-based)
}

DialogSegment

Un segment parsat de dialog multi-speaker text cu difuzor opţional şi etichete emoţionale. Utilizat cu DialogueParser şi DialogueSynthesizer pentru CosyVoice3 sinteza dialogului.

public struct DialogueSegment: Sendable, Equatable {
    public let speaker: String?   // Speaker identifier ("S1", "S2"), nil for untagged
    public let emotion: String?   // Emotion tag ("happy", "whispers"), nil if none
    public let text: String       // Cleaned text to synthesize
}

DialogParser

Parses multi-speaker dialog text cu tag-uri inline speaker ([S1]) și etichete emoționale ((happy)).

public enum DialogueParser {
    static func parse(_ text: String) -> [DialogueSegment]
    static func emotionToInstruction(_ emotion: String) -> String
}

Emoţii construite: happy/excited, sad, angry, whispers/whispering, laughs/laughing, calm, surprised, serious Etichetele necunoscute trec prin ca instrucțiuni de formă liberă.

DialogSintezator

Orchestrates multi-segment dialog sinteză cu clonarea vocii per-speaker, goluri de tăcere, și crossfade.

public enum DialogueSynthesizer {
    static func synthesize(
        segments: [DialogueSegment],
        speakerEmbeddings: [String: [Float]],
        model: CosyVoiceTTSModel,
        language: String,
        config: DialogueSynthesisConfig,
        verbose: Bool
    ) -> [Float]
}

DialogSintezăConfig

public struct DialogueSynthesisConfig: Sendable {
    public var turnGapSeconds: Float      // Default: 0.2
    public var crossfadeSeconds: Float    // Default: 0.0
    public var defaultInstruction: String // Default: "You are a helpful assistant."
    public var maxTokensPerSegment: Int   // Default: 500
}

Pipellm

Protocolul pentru integrarea modelului lingvistic cu conductele de voce. Poduri o LLM la VoicePipeline's ASR → LLM → TTS Curge.

public protocol PipelineLLM: AnyObject {
    func chat(messages: [(role: MessageRole, content: String)],
              onToken: @escaping (String, Bool) -> Void)
    func cancel()
}

Adaptor de alimentare: Qwen3PipelineLLM poduri Qwen35MLXChat la acest protocol cu curăţare jeton, anulare şi acumulare de fraze în aşteptare.

AudioIO

Managerul audio reutilizabil I/O care elimină cazaniera AVAudioEngine. Manipulează captura mic, resampling, redare, și contorizarea nivelului audio.

let audio = AudioIO()
try audio.startMicrophone(targetSampleRate: 16000) { samples in
    pipeline.pushAudio(samples)
}
audio.player.scheduleChunk(ttsOutput)
audio.stopMicrophone()

AudioIO include un StreamingAudioPlayer pentru o ieșire TTS și un AudioRingBuffer pentru un transfer audio securizat între fire de captare și de interferență.

SystemAudioTap

Captureaza mixul de iesire al sistemului, care este Mac care joaca in prezent ca mono Float32 la o rata de esantionare calumer-chosen (Core Audio procesting robinets, macOS 14.4+). Doar robinetul mono global exclude procesul curent implicit, astfel încât o aplicație propria redare nu este niciodată re-capturată, și este învelit într-un dispozitiv agregat privat care conține doar robinetul.

let tap = SystemAudioTap()
try tap.start(targetSampleRate: 16000) { samples in
    pipeline.pushAudio(samples)
}
tap.stop()

Captura supravieţuieşte switch-urilor de ieşire implicită NSAudioCaptureUsageDescription. În cazul în care permisiunea de înregistrare este respinsă, un robinet poate fi creat încă livra doar tăcere: ceas framesCaptured cresc în timp ce nonSilentFrames rămâne 0 și nu reușesc închis.

Surse independente cu timbru temporizat

Ambele clase de captare expun suprasarcini cu timbru temporal. CapturedAudioChunk poartă mono samples la sampleRate plus un Mach opțional hostTime pentru primul cadru de intrare. Deoarece ambele surse folosesc același ceas gazdă, o aplicație poate păstra evenimentele de transcriere derivate din PCM separate și ordine fără a amesteca audio.

try tap.startTimestamped(targetSampleRate: 16000) { systemChunk in
    systemPipeline.pushAudio(systemChunk.samples)
    recordSystemTime(systemChunk.hostTime)
}

let microphone = AudioIO(enableAEC: true, enablePlayback: false)
try microphone.startMicrophoneTimestamped(targetSampleRate: 16000) { micChunk in
    microphonePipeline.pushAudio(micChunk.samples)
    recordMicrophoneTime(micChunk.hostTime)
}

Pentru captarea numai de ascultare, enableAEC: true activează Apple Voice Processing înainte ca formatul microfonului să fie citit, și enablePlayback: false omite jucătorul neutilizat. Pe macOS, redarea dispozitivului este eliminată din mostrele microfonului și se raportează eșecul de pornire a AEC în loc să se retragă la intrare brută.

Intrarea și recunoașterea inițială a fișierelor

CapturedAudioChunk are, de asemenea, un monoton frameIndex și un marker isFinal. AudioFileLoader.stream produce aceste bucăți la cerere cu memorie delimitată, reeșalonări o dată cu starea persistentă a convertorului și media tuturor canalelor de intrare în mod implicit.Use .first sau .select([indices]) atunci când ruta canalului este cunoscută.

StreamingRecognitionModel și StreamingRecognitionSession provide o cache-conserving incremental API through Parakeet Streaming and Nemotron Core ML/MLX:

let source = AudioFileLoader.stream(
    url: inputURL,
    options: AudioFileStreamOptions(targetSampleRate: 16_000,
                                    chunkDuration: 0.32,
                                    channelSelection: .mixAll))
let session = try model.makeStreamingSession(language: "en-US")

for try await chunk in source {
    for update in try session.push(chunk) {
        render(update.text, final: update.isFinal)
    }
}
for update in try session.finish() {
    render(update.text, final: true)
}

SentincePieceModel

Cititor de protobuf partajat pentru SentincePiece .model fișiere, trăiește în AudioCommon. Fiecare modul care trebuie să decodeze piese de SentencePiece (PersonaPlex, OmnilingualASR, viitor ASR / TTS porturi) își construiește propriul decodor pe partea de sus a acestui singur cititor în loc să reimplementeze formatul de sârmă protobuf.

public struct SentencePieceModel: Sendable {
    public struct Piece: Sendable, Equatable {
        public let text: String
        public let score: Float
        public let type: Int32
        public var pieceType: PieceType? { get }
        public var isControlOrUnknown: Bool { get }
    }
    public enum PieceType: Int32 {
        case normal = 1, unknown = 2, control = 3,
             userDefined = 4, unused = 5, byte = 6
    }
    public let pieces: [Piece]
    public var count: Int { get }
    public subscript(_ id: Int) -> Piece? { get }
    public init(contentsOf url: URL) throws
    public init(modelPath: String) throws
    public init(data: Data) throws
}

Utilizat de: OmnilingualASR.OmnilingualVocabulary, PersonaPlex.SentencePieceDecoder. Acoperit de 7 teste unitare în Tests/AudioCommonTests/SentencePieceModelTests.

MLXCommon.SDPA

Atentie punct-produs escaladat ajutor partajat pe fiecare modul de atenţie MLX (Qwen3-ASR / Qwen3-TTS/Qwen3-Chat // CosyVoice & PersonaPlex - OmnilingualASR). Fiecare modul păstrează propriile proiecţii

public enum SDPA {
    // Flat [B, T, H*D] input: project/reshape happens inside
    public static func multiHead(
        q: MLXArray, k: MLXArray, v: MLXArray,
        numHeads: Int, headDim: Int, scale: Float,
        mask: MLXArray? = nil
    ) -> MLXArray

    // GQA / MQA variant with separate query and KV head counts
    public static func multiHead(
        q: MLXArray, k: MLXArray, v: MLXArray,
        numQueryHeads: Int, numKVHeads: Int, headDim: Int, scale: Float,
        mask: MLXArray? = nil
    ) -> MLXArray

    // Already-shaped [B, H, T, D] (RoPE / KV cache paths)
    public static func attendAndMerge(
        qHeads: MLXArray, kHeads: MLXArray, vHeads: MLXArray,
        scale: Float,
        mask: MLXArray? = nil
    ) -> MLXArray

    // Same, with ScaledDotProductAttentionMaskMode enum (newer API)
    public static func attendAndMerge(
        qHeads: MLXArray, kHeads: MLXArray, vHeads: MLXArray,
        scale: Float,
        mask: MLXFast.ScaledDotProductAttentionMaskMode
    ) -> MLXArray

    // Low-level head merge: [B, H, T, D] → [B, T, H*D]
    public static func mergeHeads(_ attn: MLXArray) -> MLXArray
}

Toate apelurile de remodelare utilizează -1 pentru dimensiunea lotului, astfel încât ajutoarele să compună cu MLX.compile(shapeless:) grafice care să varieze lotul la rulare (de exemplu Qwen3-TTS Talker decodare autoregresivă).

HTTP API Server

ă speech-server binara expune fiecare model din speech-swift sub forma unor criterii finale HTTP REST plus un criteriu final WebSocket care pune în aplicare OpenAI Realtime API. Modelele sunt încărcate lene la prima cerere; trece --preload să le încălzească pe toate la startup.

swift build -c release
.build/release/speech-server --port 8080

# Preload every model at startup
.build/release/speech-server --port 8080 --preload

REST Puncte finale

/v1/audio/speech hărţi standard TTS modele şi denumiri vocale pentru motoarele locale. Implică la WAV; response_format: "pcm" întoarce fără antet 24 kHz mono PCM16 audio mic-endian. Formatele comprimate nesusţinute sunt respinse în mod explicit.

/v1/audio/transcriptions acceptă un fișier WAV ca date multipart sub formă și implicit la {"text":"..."}; response_format poate solicita, de asemenea, text, verbose JSON, SRT, sau VTT. Pe Apple, modele pseudonime selectați un local ASR Motorul. speech-core server pe server Linux şi Windows foloseste lenes încărcat Parakeet, acceptă PCM16/24/32 sau Float32 WAV, și capace de încărcare la 25 MiB și 10 minute.

# Transcribe a file
curl -X POST http://localhost:8080/transcribe \
  --data-binary @recording.wav \
  -H "Content-Type: audio/wav"

# Synthesize speech
curl -X POST http://localhost:8080/speak \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "engine": "cosyvoice"}' \
  -o output.wav

# OpenAI-compatible transcription
curl http://localhost:8080/v1/audio/transcriptions \
  -F "[email protected];type=audio/wav" \
  -F "model=whisper-1"

# OpenAI-compatible speech synthesis
curl http://localhost:8080/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"model":"tts-1","voice":"alloy","input":"Hello world","response_format":"wav"}' \
  -o openai-output.wav

# Full speech-to-speech round trip
curl -X POST http://localhost:8080/respond \
  --data-binary @question.wav \
  -o response.wav

OpenAI Realtime API (/v1/realtime)

Obiectivul WebSocket la ws://host:port/v1/realtime pune în aplicare protocolul OpenAI Realtime. Toate mesajele sunt JSON cu un discriminatoriu type; încărcăturile utile audio sunt base64-encoded PCM16 la 24 kHz mono.

In timpul incarcarilor de modele reci sau generatii lungi, serverul emite usor realtime.keepalive Evenimente JSON si rame de control pong websocket aproximativ la fiecare 15 secunde pana cand modelul de iesire este gata. Clientii pot ignora aceste evenimente sau le trateaza ca indicatori de activitate.

Client → Evenimente server

Server → Evenimente client

Rânduri automate cu server VAD

Explicit input_audio_buffer.commit rămâne implicit. Pentru a lăsa serverul să se închidă și transcrie automat cu Silero VAD, configura turn_detection. Serverul păstrează doar pre-roll-ul solicitat în timp ce inactiv, emite start/stop și comit evenimente în ordine, și se închide continuu activ la max_turn_duration_ms.

ws.send(JSON.stringify({
  type: 'session.update',
  session: {
    turn_detection: {
      type: 'server_vad',
      threshold: 0.5,
      prefix_padding_ms: 300,
      silence_duration_ms: 500,
      max_turn_duration_ms: 120000
    }
  }
}));

// Disable automatic turns and return to explicit commits:
// { type: 'session.update', session: { turn_detection: null } }

const ws = new WebSocket('ws://localhost:8080/v1/realtime');

// ASR: push audio, request transcription
ws.send(JSON.stringify({ type: 'input_audio_buffer.append', audio: base64PCM16 }));
ws.send(JSON.stringify({ type: 'input_audio_buffer.commit' }));
// → conversation.item.input_audio_transcription.completed

// TTS: request synthesis and stream audio deltas
ws.send(JSON.stringify({
  type: 'response.create',
  response: { modalities: ['audio', 'text'], instructions: 'Hello world' }
}));
// → response.audio.delta (repeated), response.audio.done, response.done

Serverul locuiește în produsul AudioServer SPM. Un client de tip browser de exemplu este expediat la Examples/websocket-client.html deschideți-l alături de un server care rulează pentru a conduce întreaga călătorie ASR + TTS rotundă.

Modele de descărcări

Toate modelele sunt descărcate de la HuggingFace la prima utilizare și cache în ~/Library/Caches/qwen3-speech/. Modulul AudioCommon oferă un partaj HuggingFaceDownloader care se ocupă de descărcare, caching și verificarea integrității.

Descărcați retries

Modele de incarcatoare si descarca API accepta downloadOptions: DownloadOptions. onRetry a primit DownloadRetryEvent înainte de fiecare retragere, cu modelId, attempt, maxAttempts, originalul error, și retryInSeconds. nil înseamnă că nu mai rămân retensiuni; retragerea completă a cache-ului poate reuși.

Retragerile sunt sincrone și @Sendable, fără o garanție principală. Anularea nu produce un eveniment de retrie. Set retryDelaysSeconds pentru a personaliza politica ([] înseamnă o singură încercare; descărcarea explicită API argument are prioritate. Se păstrează numărul de încercări implicite și progresele octet. Încercările eșuate sunt înregistrate și la nivel de notificare prin AudioLog.download.

Anulare cooperativă

Pentru MLX transcription, Qwen3ASRModel.transcribeCheckingCancellation(audio:sampleRate:options:) aruncări CancellationError atunci când anularea sarcinii este observată înainte de extragerea caracteristicilor, codificarea, prefillarea decodorului sau o etapă de decodare. GPU munca depusă deja poate fi terminată. Cronhous transcribe și transcribeBatch API își păstrează comportamentul de non-ascensiune și ignoră anularea sarcinilor. speech-server folosește punctul de intrare pentru anulare-aware pentru Qwen3-ASR.

import AudioCommon
import MossTTSNano

let model = try await MossTTSNanoModel.fromPretrained()
let reference = try await model.encodeReference(url: referenceURL)
let result = try await model.synthesize(
    text: "The weather is nice today.", reference: reference,
    options: MossTTSNanoOptions(maxFrames: 300, seed: 1))
try WAVWriter.writeStereo(left: result.left, right: result.right,
    sampleRate: 48000, to: outputURL)

speech-server --inference-manifest models.json --port 8080

POST /v1/inference
{"operation":"chat","model":"gemma4-e4b-it","requestID":"chat-1","messages":[{"role":"user","content":"Hello"}],"maxTokens":128,"temperature":0}

chat: gemma4-e4b-it
speech: voxcpm2
transcribe: whisper-large-v3
vad: silero-vad

Audio: audioBase64 (mono PCM16), sampleRate
VAD: streamID, reset, endStream; 512 samples/frame at 16000 Hz
Tools: name, description, parameters
Tool call: id, name, arguments
Tool result: role="tool", toolCallID, content