getpatter 0.4.4 → 0.5.1

package/dist/index.d.ts

@@ -1,6 +1,300 @@
 import { EventEmitter } from 'events';
 import { Request, Response, NextFunction, Express } from 'express';
 
+/** Twilio carrier credentials holder for Patter. */
+interface TwilioCarrierOptions {
+    /** Twilio Account SID. Falls back to TWILIO_ACCOUNT_SID env var. */
+    accountSid?: string;
+    /** Twilio Auth Token. Falls back to TWILIO_AUTH_TOKEN env var. */
+    authToken?: string;
+}
+/**
+ * Twilio telephony carrier — holds Account SID + Auth Token.
+ *
+ * @example
+ * ```ts
+ * import * as twilio from "getpatter/carriers/twilio";
+ * const carrier = new twilio.Carrier();                     // reads env
+ * const carrier = new twilio.Carrier({ accountSid: "AC...", authToken: "..." });
+ * ```
+ */
+declare class Carrier$1 {
+    readonly kind: "twilio";
+    readonly accountSid: string;
+    readonly authToken: string;
+    constructor(opts?: TwilioCarrierOptions);
+}
+
+/** Telnyx carrier credentials holder for Patter. */
+interface TelnyxCarrierOptions {
+    /** Telnyx API key. Falls back to TELNYX_API_KEY env var. */
+    apiKey?: string;
+    /** Telnyx connection ID. Falls back to TELNYX_CONNECTION_ID env var. */
+    connectionId?: string;
+    /** Optional Ed25519 public key for webhook signature verification. Falls back to TELNYX_PUBLIC_KEY env var. */
+    publicKey?: string;
+}
+/**
+ * Telnyx telephony carrier — holds API key, connection ID, and optional webhook public key.
+ *
+ * @example
+ * ```ts
+ * import * as telnyx from "getpatter/carriers/telnyx";
+ * const carrier = new telnyx.Carrier();                     // reads env
+ * const carrier = new telnyx.Carrier({ apiKey: "KEY...", connectionId: "123" });
+ * ```
+ */
+declare class Carrier {
+    readonly kind: "telnyx";
+    readonly apiKey: string;
+    readonly connectionId: string;
+    readonly publicKey: string | undefined;
+    constructor(opts?: TelnyxCarrierOptions);
+}
+
+/** OpenAI Realtime engine — marker class for Patter client dispatch. */
+interface RealtimeOptions {
+    /** API key. Falls back to OPENAI_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** Realtime model. Defaults to gpt-4o-mini-realtime-preview. */
+    model?: string;
+    /** Voice preset. Defaults to alloy. */
+    voice?: string;
+}
+/**
+ * OpenAI Realtime engine marker.
+ *
+ * @example
+ * ```ts
+ * import * as openai from "getpatter/engines/openai";
+ * const engine = new openai.Realtime();                     // reads OPENAI_API_KEY
+ * const engine = new openai.Realtime({ voice: "alloy" });
+ * ```
+ */
+declare class Realtime {
+    readonly kind: "openai_realtime";
+    readonly apiKey: string;
+    readonly model: string;
+    readonly voice: string;
+    constructor(opts?: RealtimeOptions);
+}
+
+/** ElevenLabs ConvAI engine — marker class for Patter client dispatch. */
+interface ConvAIOptions {
+    /** API key. Falls back to ELEVENLABS_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** ElevenLabs Agent ID. Falls back to ELEVENLABS_AGENT_ID env var when omitted. */
+    agentId?: string;
+    /** Voice ID to override the agent's default voice. */
+    voice?: string;
+}
+/**
+ * ElevenLabs ConvAI engine marker.
+ *
+ * @example
+ * ```ts
+ * import * as elevenlabs from "getpatter/engines/elevenlabs";
+ * const engine = new elevenlabs.ConvAI();                   // reads env vars
+ * const engine = new elevenlabs.ConvAI({ agentId: "agent_..." });
+ * ```
+ */
+declare class ConvAI {
+    readonly kind: "elevenlabs_convai";
+    readonly apiKey: string;
+    readonly agentId: string;
+    readonly voice: string | undefined;
+    constructor(opts?: ConvAIOptions);
+}
+
+/** Tunnel marker classes for Patter. Dispatched by the client to decide how to expose local servers. */
+/**
+ * Cloudflare Quick Tunnel marker — ask Patter to start a cloudflared tunnel.
+ *
+ * @example
+ * ```ts
+ * import { CloudflareTunnel } from "getpatter/tunnels";
+ * const tunnel = new CloudflareTunnel();
+ * ```
+ */
+declare class CloudflareTunnel {
+    readonly kind: "cloudflare";
+}
+/**
+ * Static hostname marker — use a pre-existing public hostname (no tunnel).
+ *
+ * @example
+ * ```ts
+ * import { Static } from "getpatter/tunnels";
+ * const tunnel = new Static({ hostname: "agent.example.com" });
+ * ```
+ */
+declare class Static {
+    readonly kind: "static";
+    readonly hostname: string;
+    constructor(opts: {
+        hostname: string;
+    });
+}
+
+/**
+ * Public API primitives — `Tool` and `Guardrail` classes, plus the
+ * `tool()` / `guardrail()` factory functions.
+ *
+ * These mirror the Python SDK's `patter.Tool` / `patter.Guardrail`. The
+ * classes are structurally compatible with the existing `Guardrail`
+ * interface and `ToolDefinition` shape used internally, so code that
+ * consumed either form keeps working.
+ */
+
+interface GuardrailOptions {
+    /** Name for logging when triggered. */
+    name: string;
+    /** List of terms that trigger the guardrail (case-insensitive). */
+    blockedTerms?: string[];
+    /** Custom check function — return true to block the response. */
+    check?: (text: string) => boolean;
+    /** Replacement text spoken when guardrail triggers. */
+    replacement?: string;
+}
+/**
+ * Guardrail definition. Structurally matches the internal `Guardrail`
+ * interface so existing code consuming plain objects keeps working.
+ *
+ * @example
+ * ```ts
+ * import { Guardrail } from "getpatter";
+ * const rail = new Guardrail({ name: "profanity", blockedTerms: ["badword"] });
+ * ```
+ */
+declare class Guardrail$1 {
+    readonly name: string;
+    readonly blockedTerms?: string[];
+    readonly check?: (text: string) => boolean;
+    readonly replacement: string;
+    constructor(opts: GuardrailOptions);
+}
+/** Factory helper mirroring Python's `guardrail(...)` function. */
+declare function guardrail(opts: GuardrailOptions): Guardrail$1;
+type ToolHandler = (args: Record<string, unknown>, context: Record<string, unknown>) => Promise<string>;
+interface ToolOptions {
+    /** Tool name (visible to the LLM). */
+    name: string;
+    /** What the tool does (visible to the LLM). */
+    description?: string;
+    /** JSON Schema for tool arguments. */
+    parameters?: Record<string, unknown>;
+    /** Async function called in-process when the LLM invokes the tool. */
+    handler?: ToolHandler;
+    /** URL to POST to when the LLM invokes the tool. */
+    webhookUrl?: string;
+}
+/**
+ * Tool definition. Structurally matches `ToolDefinition` so it drops
+ * directly into `agent({ tools: [...] })`.
+ *
+ * Exactly one of `handler` or `webhookUrl` must be provided.
+ *
+ * @example
+ * ```ts
+ * import { Tool } from "getpatter";
+ * const t = new Tool({
+ *   name: "check_menu",
+ *   description: "Check available menu items",
+ *   handler: async () => JSON.stringify({ items: ["margherita"] }),
+ * });
+ * ```
+ */
+declare class Tool implements ToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly handler?: ToolHandler;
+    readonly webhookUrl?: string;
+    constructor(opts: ToolOptions);
+}
+/** Factory helper mirroring Python's `tool(...)` function. */
+declare function tool(opts: ToolOptions): Tool;
+
+/**
+ * Shared STT / TTS adapter dispatch.
+ *
+ * In v0.5.0+ callers always pass pre-instantiated adapters (``agent.stt`` /
+ * ``agent.tts`` are ``STTAdapter`` / ``TTSAdapter`` instances), so these
+ * helpers are thin pass-throughs that return the instance or null. Kept as
+ * functions so the Twilio/Telnyx bridges have a single dispatch point.
+ */
+
+interface STTTranscript {
+    text: string;
+    isFinal?: boolean;
+}
+type STTTranscriptCallback = (t: STTTranscript) => Promise<void> | void;
+/** Shape shared by every STT adapter in the SDK. */
+interface STTAdapter {
+    connect(): Promise<void>;
+    sendAudio(pcm: Buffer): void | Promise<void>;
+    onTranscript(cb: STTTranscriptCallback): void;
+    close(): void | Promise<void>;
+}
+interface TTSAdapter {
+    synthesizeStream(text: string): AsyncIterable<Buffer>;
+}
+
+/**
+ * Built-in LLM loop for pipeline mode when no onMessage handler is provided.
+ *
+ * Uses a pluggable ``LLMProvider`` interface so callers can supply OpenAI,
+ * Anthropic, Gemini, or any custom provider.  The default provider is
+ * ``OpenAILLMProvider`` which preserves full backward compatibility.
+ */
+
+/** A single streaming chunk yielded by an LLM provider. */
+interface LLMChunk {
+    type: 'text' | 'tool_call' | 'done';
+    content?: string;
+    index?: number;
+    id?: string;
+    name?: string;
+    arguments?: string;
+}
+/**
+ * Interface that any LLM provider must satisfy.
+ *
+ * Implementors yield streaming ``LLMChunk`` objects:
+ * - ``{ type: "text", content: "..." }`` — a text token.
+ * - ``{ type: "tool_call", index, id?, name?, arguments? }`` — a (partial) tool
+ *   invocation.  Chunks with the same ``index`` are concatenated.
+ * - ``{ type: "done" }`` — signals the end of the stream (optional).
+ */
+interface LLMProvider {
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+/** LLM provider backed by OpenAI Chat Completions (streaming). */
+declare class OpenAILLMProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    constructor(apiKey: string, model: string);
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+declare class LLMLoop {
+    private readonly provider;
+    private readonly systemPrompt;
+    private readonly tools;
+    private readonly openaiTools;
+    private readonly toolMap;
+    constructor(apiKey: string, model: string, systemPrompt: string, tools?: ToolDefinition[] | null, llmProvider?: LLMProvider);
+    /**
+     * Stream LLM response tokens, handling tool calls automatically.
+     * Yields text tokens as they arrive from the LLM.
+     */
+    run(userText: string, history: Array<{
+        role: string;
+        text: string;
+    }>, callContext: Record<string, unknown>): AsyncGenerator<string, void, unknown>;
+    private executeTool;
+    private buildMessages;
+}
+
 interface IncomingMessage {
     readonly text: string;
     readonly callId: string;
@@ -108,32 +402,34 @@ interface Call {
 }
 interface LocalOptions {
     /**
-     * Optional — when omitted, local mode is auto-detected from the presence of
-     * ``twilioSid`` or ``telnyxKey`` (matches the Python SDK which treats
-     * ``Patter(twilio_sid=...)`` as local mode by default).
+     * Local mode is auto-detected when a ``carrier`` is passed. Pass
+     * ``mode: 'local'`` to force local mode explicitly.
      */
     mode?: 'local';
-    twilioSid?: string;
-    twilioToken?: string;
-    openaiKey?: string;
-    phoneNumber: string;
-    webhookUrl?: string;
-    telephonyProvider?: 'twilio' | 'telnyx';
-    telnyxKey?: string;
-    telnyxConnectionId?: string;
     /**
-     * Telnyx Ed25519 public key (base64-encoded, DER/SPKI format) for webhook
-     * signature verification. When provided, unauthenticated requests are rejected.
+     * Telephony carrier instance. Required for local mode.
+     *
+     * @example
+     * ```ts
+     * import { Patter, Twilio } from "getpatter";
+     * const phone = new Patter({ carrier: new Twilio(), phoneNumber: "+1..." });
+     * ```
      */
-    telnyxPublicKey?: string;
+    carrier: Carrier$1 | Carrier;
+    /**
+     * Tunnel configuration. Accepts a tunnel instance, ``true`` (alias for
+     * ``new CloudflareTunnel()``), or ``false`` / omitted (no tunnel).
+     */
+    tunnel?: CloudflareTunnel | Static | boolean;
+    phoneNumber: string;
+    webhookUrl?: string;
     /**
-     * Provider-level Deepgram API key. When set, agents that don't override
-     * ``agent.deepgramKey`` / ``agent.stt`` use this as the default STT key.
-     * Mirrors Python's ``Patter(deepgram_key=...)``.
+     * @internal — allows ``StreamHandler`` to build the default OpenAI
+     * ``LLMLoop`` when no ``onMessage`` handler is supplied. The
+     * ``OpenAIRealtime`` engine instance carries its own key when one is
+     * used via ``phone.agent({ engine: new OpenAIRealtime({ apiKey }) })``.
      */
-    deepgramKey?: string;
-    /** Provider-level ElevenLabs API key (same semantics as ``deepgramKey``). */
-    elevenlabsKey?: string;
+    openaiKey?: string;
 }
 interface Guardrail {
     /** Name for logging when triggered */
@@ -189,23 +485,47 @@ interface BackgroundAudioPlayer$1 {
 }
 interface AgentOptions {
     systemPrompt: string;
+    /**
+     * Voice preset. When ``engine`` is provided, its ``voice`` is used unless
+     * explicitly overridden here.
+     */
     voice?: string;
+    /**
+     * LLM / Realtime model. When ``engine`` is provided, its ``model`` is used
+     * unless explicitly overridden here.
+     */
     model?: string;
     language?: string;
     firstMessage?: string;
-    tools?: ToolDefinition[];
+    /** Tool definitions — ``Tool`` class instances from ``getpatter``. */
+    tools?: Array<Tool>;
+    /**
+     * Realtime / ConvAI engine instance. When present, the agent runs in the
+     * matching mode (``openai_realtime`` or ``elevenlabs_convai``). When absent,
+     * pipeline mode is selected if ``stt`` and ``tts`` are provided.
+     */
+    engine?: Realtime | ConvAI;
+    /**
+     * Provider mode. Normally derived from ``engine`` / ``stt`` + ``tts``. Pass
+     * ``'pipeline'`` explicitly when building a pipeline-mode agent without
+     * an engine instance.
+     */
     provider?: 'openai_realtime' | 'elevenlabs_convai' | 'pipeline';
-    elevenlabsKey?: string;
-    elevenlabsAgentId?: string;
-    deepgramKey?: string;
-    /** STT provider config for pipeline mode. Use ``Patter.deepgram()`` or ``Patter.whisper()``. */
-    stt?: STTConfig;
-    /** TTS provider config for pipeline mode. Use ``Patter.elevenlabs()`` or ``Patter.openaiTts()``. */
-    tts?: TTSConfig;
+    /** Pre-instantiated STT adapter (e.g. ``new DeepgramSTT({ apiKey })``). */
+    stt?: STTAdapter;
+    /** Pre-instantiated TTS adapter (e.g. ``new ElevenLabsTTS({ apiKey })``). */
+    tts?: TTSAdapter;
+    /**
+     * Pipeline-mode LLM provider (e.g. ``new AnthropicLLM()``). When set, the
+     * built-in LLM loop uses this provider instead of the OpenAI default.
+     * Mutually exclusive with ``onMessage`` passed to ``serve()``. Ignored
+     * when ``engine`` is set (realtime mode bypasses the pipeline LLM).
+     */
+    llm?: LLMProvider;
     /** Dynamic variables for ``{placeholder}`` substitution in systemPrompt at call time. */
     variables?: Record<string, string>;
-    /** Output guardrails — filter AI responses before TTS */
-    guardrails?: Guardrail[];
+    /** Output guardrails — ``Guardrail`` class instances from ``getpatter``. */
+    guardrails?: Array<Guardrail>;
     /** Pipeline hooks — intercept and transform data at each pipeline stage (pipeline mode only). */
     hooks?: PipelineHooks;
     /** Text transforms applied to LLM output before TTS (pipeline mode only).
@@ -272,52 +592,13 @@ interface LocalCallOptions {
     ringTimeout?: number;
 }
 
-/**
- * Deepgram STT config. Tune latency via ``endpointingMs`` / ``utteranceEndMs``
- * — mirrors Python's ``Patter.deepgram(endpointing_ms=..., utterance_end_ms=...)``.
- */
-declare function deepgram(opts: {
-    apiKey: string;
-    language?: string;
-    model?: string;
-    endpointingMs?: number;
-    utteranceEndMs?: number | null;
-    smartFormat?: boolean;
-    interimResults?: boolean;
-    vadEvents?: boolean;
-}): STTConfig;
-declare function whisper(opts: {
-    apiKey: string;
-    language?: string;
-}): STTConfig;
-declare function elevenlabs(opts: {
-    apiKey: string;
-    voice?: string;
-}): TTSConfig;
-declare function openaiTts(opts: {
-    apiKey: string;
-    voice?: string;
-}): TTSConfig;
-declare function cartesia(opts: {
-    apiKey: string;
-    voice?: string;
-}): TTSConfig;
-declare function rime(opts: {
-    apiKey: string;
-    voice?: string;
-}): TTSConfig;
-declare function lmnt(opts: {
-    apiKey: string;
-    voice?: string;
-}): TTSConfig;
-
 declare class Patter {
     readonly apiKey: string;
     private readonly backendUrl;
     private readonly restUrl;
     private readonly connection;
     private readonly mode;
-    private readonly localConfig;
+    private localConfig;
     private embeddedServer;
     private tunnelHandle;
     constructor(options: PatterOptions | LocalOptions);
@@ -335,51 +616,6 @@ declare class Patter {
     }): Promise<PhoneNumber>;
     assignAgent(numberId: string, agentId: string): Promise<void>;
     listCalls(limit?: number): Promise<Call[]>;
-    static deepgram: typeof deepgram;
-    static whisper: typeof whisper;
-    static elevenlabs: typeof elevenlabs;
-    static openaiTts: typeof openaiTts;
-    static cartesia: typeof cartesia;
-    static rime: typeof rime;
-    static lmnt: typeof lmnt;
-    static guardrail(opts: {
-        name: string;
-        blockedTerms?: string[];
-        check?: (text: string) => boolean;
-        replacement?: string;
-    }): Guardrail;
-    /**
-     * Create a tool definition for use with `agent({ tools: [...] })`.
-     *
-     * Either `handler` (a function) or `webhookUrl` must be provided.
-     *
-     * @param opts.name - Tool name (visible to the LLM).
-     * @param opts.description - What the tool does (visible to the LLM).
-     * @param opts.parameters - JSON Schema for tool arguments.
-     * @param opts.handler - Async function called in-process when the LLM invokes the tool.
-     * @param opts.webhookUrl - URL to POST to when the LLM invokes the tool.
-     *
-     * @example
-     * ```ts
-     * phone.agent({
-     *   systemPrompt: 'You are a pizza bot.',
-     *   tools: [
-     *     Patter.tool({
-     *       name: 'check_menu',
-     *       description: 'Check available menu items',
-     *       handler: async (args) => JSON.stringify({ items: ['margherita'] }),
-     *     }),
-     *   ],
-     * });
-     * ```
-     */
-    static tool(opts: {
-        name: string;
-        description?: string;
-        parameters?: Record<string, unknown>;
-        handler?: (args: Record<string, unknown>, context: Record<string, unknown>) => Promise<string>;
-        webhookUrl?: string;
-    }): ToolDefinition;
     private registerNumber;
 }
 
@@ -552,6 +788,34 @@ declare class ProvisionError extends PatterError {
     constructor(message: string);
 }
 
+/**
+ * Deepgram STT config builder. Tune latency via ``endpointingMs`` /
+ * ``utteranceEndMs``. Internal only — public code should use ``DeepgramSTT``
+ * from ``getpatter/stt/deepgram``.
+ */
+declare function deepgram(opts: {
+    apiKey: string;
+    language?: string;
+    model?: string;
+    endpointingMs?: number;
+    utteranceEndMs?: number | null;
+    smartFormat?: boolean;
+    interimResults?: boolean;
+    vadEvents?: boolean;
+}): STTConfig;
+declare function whisper(opts: {
+    apiKey: string;
+    language?: string;
+}): STTConfig;
+declare function elevenlabs(opts: {
+    apiKey: string;
+    voice?: string;
+}): TTSConfig;
+declare function openaiTts(opts: {
+    apiKey: string;
+    voice?: string;
+}): TTSConfig;
+
 /**
  * Default provider pricing and merge utilities.
  *
@@ -753,109 +1017,6 @@ declare class ElevenLabsConvAIAdapter {
     close(): void;
 }
 
-interface Transcript$4 {
-    readonly text: string;
-    readonly isFinal: boolean;
-    readonly confidence: number;
-}
-type TranscriptCallback$4 = (transcript: Transcript$4) => void;
-/**
- * Optional tuning knobs for Deepgram live transcription.
- *
- * Mirrors Python's ``DeepgramSTT`` kwargs so callers can lower turn latency
- * without monkey-patching (BUG #13).
- */
-interface DeepgramSTTOptions {
-    /** Model name. Default ``nova-3``. */
-    readonly model?: string;
-    /** Audio encoding (``linear16`` | ``mulaw`` | etc). Default ``linear16``. */
-    readonly encoding?: string;
-    /** Sample rate in Hz. Default ``16000``. */
-    readonly sampleRate?: number;
-    /**
-     * Voice-activity endpointing threshold in milliseconds.
-     * Lower values reduce turn latency at the cost of more false-start cuts.
-     * Default ``150``.
-     */
-    readonly endpointingMs?: number;
-    /**
-     * End-of-utterance silence window in milliseconds. Deepgram enforces a
-     * hard minimum of 1000 ms. Set to ``null`` to disable. Default ``1000``.
-     */
-    readonly utteranceEndMs?: number | null;
-    /** Enable smart formatting (punctuation + numerals). Default ``true``. */
-    readonly smartFormat?: boolean;
-    /** Emit interim (non-final) transcripts. Default ``true``. */
-    readonly interimResults?: boolean;
-    /** Emit VAD events (``SpeechStarted`` / ``UtteranceEnd``). Default ``true``. */
-    readonly vadEvents?: boolean;
-}
-declare class DeepgramSTT {
-    private ws;
-    private callbacks;
-    /** Request ID from Deepgram — used to query actual cost post-call. */
-    requestId: string;
-    private readonly apiKey;
-    private readonly language;
-    private readonly model;
-    private readonly encoding;
-    private readonly sampleRate;
-    private readonly endpointingMs;
-    private readonly utteranceEndMs;
-    private readonly smartFormat;
-    private readonly interimResults;
-    private readonly vadEvents;
-    /**
-     * New ergonomic constructor accepting an options object (mirrors Python kwargs).
-     *
-     * Also accepts the legacy positional form
-     * ``(apiKey, language?, model?, encoding?, sampleRate?)`` for backward
-     * compatibility with code that predated BUG #13.
-     */
-    constructor(apiKey: string, language?: string, model?: string, encoding?: string, sampleRate?: number, options?: DeepgramSTTOptions);
-    constructor(apiKey: string, options: DeepgramSTTOptions & {
-        language?: string;
-    });
-    /** Factory for Twilio calls — mulaw 8 kHz. Forwards tuning options through. */
-    static forTwilio(apiKey: string, language?: string, model?: string, options?: DeepgramSTTOptions): DeepgramSTT;
-    connect(): Promise<void>;
-    sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback$4): void;
-    close(): void;
-}
-
-/**
- * OpenAI Whisper STT adapter for the Patter SDK pipeline mode.
- *
- * Buffers incoming PCM16 audio and periodically sends it to the
- * OpenAI Whisper transcription API as a WAV file.
- */
-interface Transcript$3 {
-    readonly text: string;
-    readonly isFinal: boolean;
-    readonly confidence: number;
-}
-type TranscriptCallback$3 = (transcript: Transcript$3) => void;
-declare class WhisperSTT {
-    private readonly apiKey;
-    private readonly model;
-    private readonly language;
-    private readonly bufferSize;
-    private buffer;
-    private callbacks;
-    private running;
-    private pendingTranscriptions;
-    constructor(apiKey: string, model?: string, language?: string, bufferSize?: number);
-    /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
-    static forTwilio(apiKey: string, language?: string, model?: string): WhisperSTT;
-    connect(): Promise<void>;
-    sendAudio(audio: Buffer): void;
-    private trackTranscription;
-    onTranscript(callback: TranscriptCallback$3): void;
-    close(): Promise<void>;
-    private transcribeBuffer;
-}
-
 /**
  * In-memory metrics store for the local dashboard.
  *
@@ -1052,61 +1213,6 @@ declare function mountApi(app: Express, store: MetricsStore, token?: string): vo
  */
 declare function notifyDashboard(callData: Record<string, unknown>, port?: number): void;
 
-/**
- * Built-in LLM loop for pipeline mode when no onMessage handler is provided.
- *
- * Uses a pluggable ``LLMProvider`` interface so callers can supply OpenAI,
- * Anthropic, Gemini, or any custom provider.  The default provider is
- * ``OpenAILLMProvider`` which preserves full backward compatibility.
- */
-
-/** A single streaming chunk yielded by an LLM provider. */
-interface LLMChunk {
-    type: 'text' | 'tool_call' | 'done';
-    content?: string;
-    index?: number;
-    id?: string;
-    name?: string;
-    arguments?: string;
-}
-/**
- * Interface that any LLM provider must satisfy.
- *
- * Implementors yield streaming ``LLMChunk`` objects:
- * - ``{ type: "text", content: "..." }`` — a text token.
- * - ``{ type: "tool_call", index, id?, name?, arguments? }`` — a (partial) tool
- *   invocation.  Chunks with the same ``index`` are concatenated.
- * - ``{ type: "done" }`` — signals the end of the stream (optional).
- */
-interface LLMProvider {
-    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
-}
-/** LLM provider backed by OpenAI Chat Completions (streaming). */
-declare class OpenAILLMProvider implements LLMProvider {
-    private readonly apiKey;
-    private readonly model;
-    constructor(apiKey: string, model: string);
-    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
-}
-declare class LLMLoop {
-    private readonly provider;
-    private readonly systemPrompt;
-    private readonly tools;
-    private readonly openaiTools;
-    private readonly toolMap;
-    constructor(apiKey: string, model: string, systemPrompt: string, tools?: ToolDefinition[] | null, llmProvider?: LLMProvider);
-    /**
-     * Stream LLM response tokens, handling tool calls automatically.
-     * Yields text tokens as they arrive from the LLM.
-     */
-    run(userText: string, history: Array<{
-        role: string;
-        text: string;
-    }>, callContext: Record<string, unknown>): AsyncGenerator<string, void, unknown>;
-    private executeTool;
-    private buildMessages;
-}
-
 /**
  * Fallback LLM provider that tries multiple providers in sequence.
  *
@@ -1358,13 +1464,13 @@ declare function scheduleInterval(intervalOrOpts: number | {
  * `speechmatics` extra; TypeScript users need to wait for an official
  * upstream SDK before this adapter can land without a WS-handshake reimpl.
  */
-interface Transcript$2 {
+interface Transcript$4 {
     readonly text: string;
     readonly isFinal: boolean;
     readonly confidence: number;
 }
-type TranscriptCallback$2 = (transcript: Transcript$2) => void;
-interface SonioxSTTOptions {
+type TranscriptCallback$4 = (transcript: Transcript$4) => void;
+interface SonioxSTTOptions$1 {
     model?: string;
     languageHints?: string[];
     languageHintsStrict?: boolean;
@@ -1392,7 +1498,7 @@ declare class SonioxSTT {
     private readonly maxEndpointDelayMs;
     private readonly clientReferenceId?;
     private readonly baseUrl;
-    constructor(apiKey: string, options?: SonioxSTTOptions);
+    constructor(apiKey: string, options?: SonioxSTTOptions$1);
     /** Factory for Twilio-style 8 kHz linear PCM. */
     static forTwilio(apiKey: string, languageHints?: string[]): SonioxSTT;
     private buildConfig;
@@ -1401,7 +1507,7 @@ declare class SonioxSTT {
     private handleMessage;
     private emit;
     sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback$2): void;
+    onTranscript(callback: TranscriptCallback$4): void;
     close(): void;
 }
 
@@ -1416,15 +1522,15 @@ declare class SonioxSTT {
  * Source: livekit-plugins/livekit-plugins-assemblyai/livekit/plugins/assemblyai/stt.py
  * Upstream ref SHA: 78a66bcf79c5cea82989401c408f1dff4b961a5b
  */
-interface Transcript$1 {
+interface Transcript$3 {
     readonly text: string;
     readonly isFinal: boolean;
     readonly confidence: number;
 }
-type TranscriptCallback$1 = (transcript: Transcript$1) => void;
+type TranscriptCallback$3 = (transcript: Transcript$3) => void;
 type AssemblyAIEncoding = 'pcm_s16le' | 'pcm_mulaw';
 type AssemblyAIModel = 'universal-streaming-english' | 'universal-streaming-multilingual' | 'u3-rt-pro';
-interface AssemblyAISTTOptions {
+interface AssemblyAISTTOptions$1 {
     /** One of the AssemblyAI speech models. */
     readonly model?: AssemblyAIModel;
     /** PCM encoding: 16-bit little-endian (default) or G.711 mu-law for telephony. */
@@ -1465,7 +1571,7 @@ declare class AssemblyAISTT {
     sessionId: string;
     /** Unix timestamp when the AssemblyAI session expires. */
     expiresAt: number;
-    constructor(apiKey: string, options?: AssemblyAISTTOptions);
+    constructor(apiKey: string, options?: AssemblyAISTTOptions$1);
     /** Factory for Twilio calls — mulaw 8 kHz. */
     static forTwilio(apiKey: string, model?: AssemblyAIModel): AssemblyAISTT;
     private buildUrl;
@@ -1473,7 +1579,7 @@ declare class AssemblyAISTT {
     private handleEvent;
     private emit;
     sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback$1): void;
+    onTranscript(callback: TranscriptCallback$3): void;
     close(): void;
 }
 
@@ -1488,15 +1594,15 @@ declare class AssemblyAISTT {
  * Source: livekit-plugins/livekit-plugins-cartesia/livekit/plugins/cartesia/stt.py
  * Upstream ref SHA: 78a66bcf79c5cea82989401c408f1dff4b961a5b
  */
-interface Transcript {
+interface Transcript$2 {
     readonly text: string;
     readonly isFinal: boolean;
     readonly confidence: number;
 }
-type TranscriptCallback = (transcript: Transcript) => void;
+type TranscriptCallback$2 = (transcript: Transcript$2) => void;
 /** Cartesia STT currently only accepts 16-bit PCM little-endian. */
 type CartesiaEncoding = 'pcm_s16le';
-interface CartesiaSTTOptions {
+interface CartesiaSTTOptions$1 {
     /** Cartesia STT model. Currently only `"ink-whisper"`. */
     readonly model?: string;
     /** BCP-47 language code. */
@@ -1516,98 +1622,418 @@ declare class CartesiaSTT {
     private keepaliveTimer;
     /** Cartesia request id — set from the server transcript events. */
     requestId: string;
-    constructor(apiKey: string, options?: CartesiaSTTOptions);
+    constructor(apiKey: string, options?: CartesiaSTTOptions$1);
     private buildWsUrl;
     connect(): Promise<void>;
     private handleEvent;
     private emit;
     sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback): void;
+    onTranscript(callback: TranscriptCallback$2): void;
     close(): void;
 }
 
-declare class ElevenLabsTTS {
-    private readonly apiKey;
-    private readonly modelId;
-    private readonly outputFormat;
-    private readonly voiceId;
-    constructor(apiKey: string, voiceId?: string, modelId?: string, outputFormat?: string);
-    /**
-     * Synthesise text to speech and return the full audio as a single Buffer.
-     *
-     * For large chunks (or when latency matters) call `synthesizeStream` instead.
-     */
-    synthesize(text: string): Promise<Buffer>;
-    /**
-     * Synthesise text and yield audio chunks as they arrive (streaming).
-     *
-     * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
-     * configured to).
-     */
-    synthesizeStream(text: string): AsyncGenerator<Buffer>;
-}
-
-declare class OpenAITTS {
-    private readonly apiKey;
-    private readonly voice;
-    private readonly model;
-    constructor(apiKey: string, voice?: string, model?: string);
-    /**
-     * Synthesise text to speech and return the full audio as a single Buffer.
-     *
-     * For large chunks (or when latency matters) call `synthesizeStream` instead.
-     */
-    synthesize(text: string): Promise<Buffer>;
-    /**
-     * Synthesise text and yield audio chunks as they arrive (streaming).
-     *
-     * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
-     * yielding so the output is ready for telephony pipelines.
-     *
-     * The resampler carries state (buffered samples + odd trailing byte)
-     * between chunks — without that state cross-chunk sample alignment drifts
-     * and the caller hears pops / dropped audio (BUG #23, mirror of the
-     * Python `audioop.ratecv` fix).
-     */
-    synthesizeStream(text: string): AsyncGenerator<Buffer>;
-    /**
-     * Streaming 24 kHz → 16 kHz resampler (PCM16-LE). Maintains cross-chunk
-     * state so the 3:2 pattern doesn't reset at every network read.
-     */
-    static resampleStreaming(audio: Buffer, ctx: {
-        carryByte: number | null;
-        leftover: number[];
-    }): Buffer;
-    /** @deprecated use {@link resampleStreaming} with persistent state. */
-    static resample24kTo16k(audio: Buffer): Buffer;
-}
-
-interface CartesiaTTSOptions {
-    model?: string;
+type LMNTAudioFormat = 'aac' | 'mp3' | 'mulaw' | 'raw' | 'wav';
+type LMNTModel = 'blizzard' | 'aurora';
+type LMNTSampleRate = 8000 | 16000 | 24000;
+interface LMNTTTSOptions$1 {
+    model?: LMNTModel;
     voice?: string;
     language?: string;
-    sampleRate?: number;
-    speed?: string | number;
-    emotion?: string | string[];
-    volume?: number;
+    format?: LMNTAudioFormat;
+    sampleRate?: LMNTSampleRate;
+    temperature?: number;
+    topP?: number;
     baseUrl?: string;
-    apiVersion?: string;
 }
-declare class CartesiaTTS {
+declare class LMNTTTS {
     private readonly apiKey;
     private readonly model;
     private readonly voice;
     private readonly language;
+    private readonly format;
     private readonly sampleRate;
-    private readonly speed?;
-    private readonly emotion?;
-    private readonly volume?;
+    private readonly temperature;
+    private readonly topP;
     private readonly baseUrl;
-    private readonly apiVersion;
-    constructor(apiKey: string, opts?: CartesiaTTSOptions);
-    /** Build the JSON payload for the Cartesia bytes endpoint. */
+    constructor(apiKey: string, opts?: LMNTTTSOptions$1);
     private buildPayload;
-    /** Synthesize text and return the concatenated audio buffer. */
+    synthesize(text: string): Promise<Buffer>;
+    /** Yield audio chunks as they arrive — raw PCM_S16LE by default. */
+    synthesizeStream(text: string): AsyncGenerator<Buffer>;
+}
+
+interface Transcript$1 {
+    readonly text: string;
+    readonly isFinal: boolean;
+    readonly confidence: number;
+}
+type TranscriptCallback$1 = (transcript: Transcript$1) => void;
+/**
+ * Optional tuning knobs for Deepgram live transcription.
+ *
+ * Mirrors Python's ``DeepgramSTT`` kwargs so callers can lower turn latency
+ * without monkey-patching (BUG #13).
+ */
+interface DeepgramSTTOptions$1 {
+    /** Model name. Default ``nova-3``. */
+    readonly model?: string;
+    /** Audio encoding (``linear16`` | ``mulaw`` | etc). Default ``linear16``. */
+    readonly encoding?: string;
+    /** Sample rate in Hz. Default ``16000``. */
+    readonly sampleRate?: number;
+    /**
+     * Voice-activity endpointing threshold in milliseconds.
+     * Lower values reduce turn latency at the cost of more false-start cuts.
+     * Default ``150``.
+     */
+    readonly endpointingMs?: number;
+    /**
+     * End-of-utterance silence window in milliseconds. Deepgram enforces a
+     * hard minimum of 1000 ms. Set to ``null`` to disable. Default ``1000``.
+     */
+    readonly utteranceEndMs?: number | null;
+    /** Enable smart formatting (punctuation + numerals). Default ``true``. */
+    readonly smartFormat?: boolean;
+    /** Emit interim (non-final) transcripts. Default ``true``. */
+    readonly interimResults?: boolean;
+    /** Emit VAD events (``SpeechStarted`` / ``UtteranceEnd``). Default ``true``. */
+    readonly vadEvents?: boolean;
+}
+declare class DeepgramSTT {
+    private ws;
+    private callbacks;
+    /** Request ID from Deepgram — used to query actual cost post-call. */
+    requestId: string;
+    private readonly apiKey;
+    private readonly language;
+    private readonly model;
+    private readonly encoding;
+    private readonly sampleRate;
+    private readonly endpointingMs;
+    private readonly utteranceEndMs;
+    private readonly smartFormat;
+    private readonly interimResults;
+    private readonly vadEvents;
+    /**
+     * New ergonomic constructor accepting an options object (mirrors Python kwargs).
+     *
+     * Also accepts the legacy positional form
+     * ``(apiKey, language?, model?, encoding?, sampleRate?)`` for backward
+     * compatibility with code that predated BUG #13.
+     */
+    constructor(apiKey: string, language?: string, model?: string, encoding?: string, sampleRate?: number, options?: DeepgramSTTOptions$1);
+    constructor(apiKey: string, options: DeepgramSTTOptions$1 & {
+        language?: string;
+    });
+    /** Factory for Twilio calls — mulaw 8 kHz. Forwards tuning options through. */
+    static forTwilio(apiKey: string, language?: string, model?: string, options?: DeepgramSTTOptions$1): DeepgramSTT;
+    connect(): Promise<void>;
+    sendAudio(audio: Buffer): void;
+    onTranscript(callback: TranscriptCallback$1): void;
+    close(): void;
+}
+
+/** Deepgram streaming STT for Patter pipeline mode. */
+
+interface DeepgramSTTOptions {
+    /** API key. Falls back to DEEPGRAM_API_KEY env var when omitted. */
+    apiKey?: string;
+    language?: string;
+    model?: string;
+    encoding?: string;
+    sampleRate?: number;
+    endpointingMs?: number;
+    utteranceEndMs?: number | null;
+    smartFormat?: boolean;
+    interimResults?: boolean;
+    vadEvents?: boolean;
+}
+/**
+ * Deepgram streaming STT.
+ *
+ * @example
+ * ```ts
+ * import * as deepgram from "getpatter/stt/deepgram";
+ * const stt = new deepgram.STT();              // reads DEEPGRAM_API_KEY
+ * const stt = new deepgram.STT({ apiKey: "dg_...", endpointingMs: 80 });
+ * ```
+ */
+declare class STT$4 extends DeepgramSTT {
+    constructor(opts?: DeepgramSTTOptions);
+}
+
+/**
+ * OpenAI Whisper STT adapter for the Patter SDK pipeline mode.
+ *
+ * Buffers incoming PCM16 audio and periodically sends it to the
+ * OpenAI Whisper transcription API as a WAV file.
+ */
+interface Transcript {
+    readonly text: string;
+    readonly isFinal: boolean;
+    readonly confidence: number;
+}
+type TranscriptCallback = (transcript: Transcript) => void;
+declare class WhisperSTT {
+    private readonly apiKey;
+    private readonly model;
+    private readonly language;
+    private readonly bufferSize;
+    private buffer;
+    private callbacks;
+    private running;
+    private pendingTranscriptions;
+    constructor(apiKey: string, model?: string, language?: string, bufferSize?: number);
+    /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
+    static forTwilio(apiKey: string, language?: string, model?: string): WhisperSTT;
+    connect(): Promise<void>;
+    sendAudio(audio: Buffer): void;
+    private trackTranscription;
+    onTranscript(callback: TranscriptCallback): void;
+    close(): Promise<void>;
+    private transcribeBuffer;
+}
+
+/** OpenAI Whisper STT for Patter pipeline mode. */
+
+interface WhisperSTTOptions {
+    /** API key. Falls back to OPENAI_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: string;
+    language?: string;
+    bufferSize?: number;
+}
+/**
+ * OpenAI Whisper STT.
+ *
+ * @example
+ * ```ts
+ * import * as whisper from "getpatter/stt/whisper";
+ * const stt = new whisper.STT();              // reads OPENAI_API_KEY
+ * const stt = new whisper.STT({ apiKey: "sk-...", language: "en" });
+ * ```
+ */
+declare class STT$3 extends WhisperSTT {
+    constructor(opts?: WhisperSTTOptions);
+}
+
+/** Cartesia streaming STT for Patter pipeline mode. */
+
+interface CartesiaSTTOptions {
+    /** API key. Falls back to CARTESIA_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: string;
+    language?: string;
+    encoding?: CartesiaEncoding;
+    sampleRate?: number;
+    baseUrl?: string;
+}
+/**
+ * Cartesia streaming STT (ink-whisper).
+ *
+ * @example
+ * ```ts
+ * import * as cartesia from "getpatter/stt/cartesia";
+ * const stt = new cartesia.STT();              // reads CARTESIA_API_KEY
+ * const stt = new cartesia.STT({ apiKey: "..." });
+ * ```
+ */
+declare class STT$2 extends CartesiaSTT {
+    constructor(opts?: CartesiaSTTOptions);
+}
+
+/** Soniox streaming STT for Patter pipeline mode. */
+
+interface SonioxSTTOptions {
+    /** API key. Falls back to SONIOX_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: string;
+    languageHints?: string[];
+    languageHintsStrict?: boolean;
+    sampleRate?: number;
+    numChannels?: number;
+    enableSpeakerDiarization?: boolean;
+    enableLanguageIdentification?: boolean;
+    maxEndpointDelayMs?: number;
+    clientReferenceId?: string;
+    baseUrl?: string;
+}
+/**
+ * Soniox streaming STT.
+ *
+ * @example
+ * ```ts
+ * import * as soniox from "getpatter/stt/soniox";
+ * const stt = new soniox.STT();              // reads SONIOX_API_KEY
+ * const stt = new soniox.STT({ apiKey: "..." });
+ * ```
+ */
+declare class STT$1 extends SonioxSTT {
+    constructor(opts?: SonioxSTTOptions);
+}
+
+/** AssemblyAI Universal Streaming STT for Patter pipeline mode. */
+
+interface AssemblyAISTTOptions {
+    /** API key. Falls back to ASSEMBLYAI_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: AssemblyAIModel;
+    encoding?: AssemblyAIEncoding;
+    sampleRate?: number;
+    baseUrl?: string;
+    languageDetection?: boolean;
+    endOfTurnConfidenceThreshold?: number;
+    minTurnSilence?: number;
+    maxTurnSilence?: number;
+    formatTurns?: boolean;
+    keytermsPrompt?: readonly string[];
+    prompt?: string;
+    vadThreshold?: number;
+    speakerLabels?: boolean;
+    maxSpeakers?: number;
+    domain?: string;
+}
+/**
+ * AssemblyAI Universal Streaming STT.
+ *
+ * @example
+ * ```ts
+ * import * as assemblyai from "getpatter/stt/assemblyai";
+ * const stt = new assemblyai.STT();              // reads ASSEMBLYAI_API_KEY
+ * const stt = new assemblyai.STT({ apiKey: "..." });
+ * ```
+ */
+declare class STT extends AssemblyAISTT {
+    constructor(opts?: AssemblyAISTTOptions);
+}
+
+declare class ElevenLabsTTS {
+    private readonly apiKey;
+    private readonly modelId;
+    private readonly outputFormat;
+    private readonly voiceId;
+    constructor(apiKey: string, voiceId?: string, modelId?: string, outputFormat?: string);
+    /**
+     * Synthesise text to speech and return the full audio as a single Buffer.
+     *
+     * For large chunks (or when latency matters) call `synthesizeStream` instead.
+     */
+    synthesize(text: string): Promise<Buffer>;
+    /**
+     * Synthesise text and yield audio chunks as they arrive (streaming).
+     *
+     * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
+     * configured to).
+     */
+    synthesizeStream(text: string): AsyncGenerator<Buffer>;
+}
+
+/** ElevenLabs TTS for Patter pipeline mode. */
+
+interface ElevenLabsTTSOptions {
+    /** API key. Falls back to ELEVENLABS_API_KEY env var when omitted. */
+    apiKey?: string;
+    voiceId?: string;
+    modelId?: string;
+    outputFormat?: string;
+}
+/**
+ * ElevenLabs TTS.
+ *
+ * @example
+ * ```ts
+ * import * as elevenlabs from "getpatter/tts/elevenlabs";
+ * const tts = new elevenlabs.TTS();              // reads ELEVENLABS_API_KEY
+ * const tts = new elevenlabs.TTS({ apiKey: "...", voiceId: "rachel" });
+ * ```
+ */
+declare class TTS$4 extends ElevenLabsTTS {
+    constructor(opts?: ElevenLabsTTSOptions);
+}
+
+declare class OpenAITTS {
+    private readonly apiKey;
+    private readonly voice;
+    private readonly model;
+    constructor(apiKey: string, voice?: string, model?: string);
+    /**
+     * Synthesise text to speech and return the full audio as a single Buffer.
+     *
+     * For large chunks (or when latency matters) call `synthesizeStream` instead.
+     */
+    synthesize(text: string): Promise<Buffer>;
+    /**
+     * Synthesise text and yield audio chunks as they arrive (streaming).
+     *
+     * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
+     * yielding so the output is ready for telephony pipelines.
+     *
+     * The resampler carries state (buffered samples + odd trailing byte)
+     * between chunks — without that state cross-chunk sample alignment drifts
+     * and the caller hears pops / dropped audio (BUG #23, mirror of the
+     * Python `audioop.ratecv` fix).
+     */
+    synthesizeStream(text: string): AsyncGenerator<Buffer>;
+    /**
+     * Streaming 24 kHz → 16 kHz resampler (PCM16-LE). Maintains cross-chunk
+     * state so the 3:2 pattern doesn't reset at every network read.
+     */
+    static resampleStreaming(audio: Buffer, ctx: {
+        carryByte: number | null;
+        leftover: number[];
+    }): Buffer;
+    /** @deprecated use {@link resampleStreaming} with persistent state. */
+    static resample24kTo16k(audio: Buffer): Buffer;
+}
+
+/** OpenAI TTS for Patter pipeline mode. */
+
+interface OpenAITTSOptions {
+    /** API key. Falls back to OPENAI_API_KEY env var when omitted. */
+    apiKey?: string;
+    voice?: string;
+    model?: string;
+}
+/**
+ * OpenAI TTS.
+ *
+ * @example
+ * ```ts
+ * import * as openai from "getpatter/tts/openai";
+ * const tts = new openai.TTS();              // reads OPENAI_API_KEY
+ * const tts = new openai.TTS({ apiKey: "sk-...", voice: "alloy" });
+ * ```
+ */
+declare class TTS$3 extends OpenAITTS {
+    constructor(opts?: OpenAITTSOptions);
+}
+
+interface CartesiaTTSOptions$1 {
+    model?: string;
+    voice?: string;
+    language?: string;
+    sampleRate?: number;
+    speed?: string | number;
+    emotion?: string | string[];
+    volume?: number;
+    baseUrl?: string;
+    apiVersion?: string;
+}
+declare class CartesiaTTS {
+    private readonly apiKey;
+    private readonly model;
+    private readonly voice;
+    private readonly language;
+    private readonly sampleRate;
+    private readonly speed?;
+    private readonly emotion?;
+    private readonly volume?;
+    private readonly baseUrl;
+    private readonly apiVersion;
+    constructor(apiKey: string, opts?: CartesiaTTSOptions$1);
+    /** Build the JSON payload for the Cartesia bytes endpoint. */
+    private buildPayload;
+    /** Synthesize text and return the concatenated audio buffer. */
     synthesize(text: string): Promise<Buffer>;
     /**
      * Synthesize text and yield raw PCM_S16LE chunks at the configured
@@ -1616,7 +2042,36 @@ declare class CartesiaTTS {
     synthesizeStream(text: string): AsyncGenerator<Buffer>;
 }
 
-interface RimeTTSOptions {
+/** Cartesia TTS for Patter pipeline mode. */
+
+interface CartesiaTTSOptions {
+    /** API key. Falls back to CARTESIA_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: string;
+    voice?: string;
+    language?: string;
+    sampleRate?: number;
+    speed?: string | number;
+    emotion?: string | string[];
+    volume?: number;
+    baseUrl?: string;
+    apiVersion?: string;
+}
+/**
+ * Cartesia TTS (sonic-2).
+ *
+ * @example
+ * ```ts
+ * import * as cartesia from "getpatter/tts/cartesia";
+ * const tts = new cartesia.TTS();              // reads CARTESIA_API_KEY
+ * const tts = new cartesia.TTS({ apiKey: "..." });
+ * ```
+ */
+declare class TTS$2 extends CartesiaTTS {
+    constructor(opts?: CartesiaTTSOptions);
+}
+
+interface RimeTTSOptions$1 {
     model?: string;
     speaker?: string;
     lang?: string;
@@ -1647,7 +2102,7 @@ declare class RimeTTS {
     private readonly phonemizeBetweenBrackets?;
     private readonly baseUrl;
     private readonly totalTimeoutMs;
-    constructor(apiKey: string, opts?: RimeTTSOptions);
+    constructor(apiKey: string, opts?: RimeTTSOptions$1);
     private buildPayload;
     synthesize(text: string): Promise<Buffer>;
     /**
@@ -1657,10 +2112,44 @@ declare class RimeTTS {
     synthesizeStream(text: string): AsyncGenerator<Buffer>;
 }
 
-type LMNTAudioFormat = 'aac' | 'mp3' | 'mulaw' | 'raw' | 'wav';
-type LMNTModel = 'blizzard' | 'aurora';
-type LMNTSampleRate = 8000 | 16000 | 24000;
+/** Rime TTS for Patter pipeline mode. */
+
+interface RimeTTSOptions {
+    /** API key. Falls back to RIME_API_KEY env var when omitted. */
+    apiKey?: string;
+    model?: string;
+    speaker?: string;
+    lang?: string;
+    sampleRate?: number;
+    repetitionPenalty?: number;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    speedAlpha?: number;
+    reduceLatency?: boolean;
+    pauseBetweenBrackets?: boolean;
+    phonemizeBetweenBrackets?: boolean;
+    baseUrl?: string;
+}
+/**
+ * Rime TTS (Arcana or Mist models).
+ *
+ * @example
+ * ```ts
+ * import * as rime from "getpatter/tts/rime";
+ * const tts = new rime.TTS();              // reads RIME_API_KEY
+ * const tts = new rime.TTS({ apiKey: "...", speaker: "astra" });
+ * ```
+ */
+declare class TTS$1 extends RimeTTS {
+    constructor(opts?: RimeTTSOptions);
+}
+
+/** LMNT TTS for Patter pipeline mode. */
+
 interface LMNTTTSOptions {
+    /** API key. Falls back to LMNT_API_KEY env var when omitted. */
+    apiKey?: string;
     model?: LMNTModel;
     voice?: string;
     language?: string;
@@ -1670,21 +2159,318 @@ interface LMNTTTSOptions {
     topP?: number;
     baseUrl?: string;
 }
-declare class LMNTTTS {
+/**
+ * LMNT TTS (blizzard/aurora).
+ *
+ * @example
+ * ```ts
+ * import * as lmnt from "getpatter/tts/lmnt";
+ * const tts = new lmnt.TTS();              // reads LMNT_API_KEY
+ * const tts = new lmnt.TTS({ apiKey: "...", voice: "leah" });
+ * ```
+ */
+declare class TTS extends LMNTTTS {
+    constructor(opts?: LMNTTTSOptions);
+}
+
+/** OpenAI LLM for Patter pipeline mode. */
+
+interface OpenAILLMOptions {
+    /** API key. Falls back to OPENAI_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** Chat Completions model id. Defaults to ``"gpt-4o-mini"``. */
+    model?: string;
+}
+/**
+ * OpenAI Chat Completions LLM provider.
+ *
+ * @example
+ * ```ts
+ * import * as openai from "getpatter/llm/openai";
+ * const llm = new openai.LLM();                           // reads OPENAI_API_KEY
+ * const llm = new openai.LLM({ apiKey: "sk-...", model: "gpt-4o-mini" });
+ * ```
+ */
+declare class LLM$4 extends OpenAILLMProvider {
+    constructor(opts?: OpenAILLMOptions);
+}
+
+/**
+ * Anthropic Claude LLM provider for Patter's pipeline mode.
+ *
+ * Implements the ``LLMProvider`` interface from ``../llm-loop`` on top
+ * of Anthropic's Messages API with streaming via Server-Sent Events.
+ * OpenAI-style ``messages`` / ``tools`` inputs are translated into the
+ * Anthropic shape and the vendor event stream is normalised back into
+ * Patter's ``{ type: 'text' | 'tool_call' | 'done' }`` chunk protocol.
+ *
+ * Portions adapted from LiveKit Agents
+ * (https://github.com/livekit/agents, commit
+ * 78a66bcf79c5cea82989401c408f1dff4b961a5b,
+ * file livekit-plugins/livekit-plugins-anthropic/livekit/plugins/anthropic/llm.py),
+ * licensed under Apache License 2.0. Copyright 2023 LiveKit, Inc.
+ *
+ * Adaptations from the LiveKit source:
+ *   * Ported the Python async class pair (``llm.LLM`` /
+ *     ``llm.LLMStream``) into a single TypeScript class that satisfies
+ *     Patter's ``LLMProvider`` interface.
+ *   * Uses native ``fetch`` + SSE parsing instead of the official
+ *     ``@anthropic-ai/sdk`` to keep Patter's runtime dependencies lean
+ *     (mirrors how ``OpenAILLMProvider`` is implemented in
+ *     ``llm-loop.ts``).
+ *   * Maps Anthropic event types (``content_block_start``,
+ *     ``content_block_delta``, ``content_block_stop``) to the Patter
+ *     chunk protocol.
+ */
+
+interface AnthropicLLMOptions$1 {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    baseUrl?: string;
+    anthropicVersion?: string;
+}
+/** LLM provider backed by Anthropic's Messages API (streaming). */
+declare class AnthropicLLMProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    private readonly temperature?;
+    private readonly url;
+    private readonly anthropicVersion;
+    constructor(options: AnthropicLLMOptions$1);
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+
+/** Anthropic Claude LLM for Patter pipeline mode. */
+
+interface AnthropicLLMOptions {
+    /** API key. Falls back to ANTHROPIC_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** Anthropic Messages API model id (e.g. ``"claude-3-5-sonnet-20241022"``). */
+    model?: string;
+    /** Maximum number of tokens to sample. Defaults to the adapter default. */
+    maxTokens?: number;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Override the Messages API base URL (rarely needed). */
+    baseUrl?: string;
+    /** ``anthropic-version`` header override. */
+    anthropicVersion?: string;
+}
+/**
+ * Anthropic Claude LLM provider (Messages API, streaming).
+ *
+ * @example
+ * ```ts
+ * import * as anthropic from "getpatter/llm/anthropic";
+ * const llm = new anthropic.LLM();                                   // reads ANTHROPIC_API_KEY
+ * const llm = new anthropic.LLM({ apiKey: "sk-ant-...", model: "claude-3-5-sonnet-20241022" });
+ * ```
+ */
+declare class LLM$3 extends AnthropicLLMProvider {
+    constructor(opts?: AnthropicLLMOptions);
+}
+
+/**
+ * Groq LLM provider for Patter's pipeline mode.
+ *
+ * Groq exposes an OpenAI-compatible Chat Completions API. We reuse the
+ * streaming code path by implementing the same SSE parser as
+ * ``OpenAILLMProvider`` but pointed at ``api.groq.com``.
+ *
+ * Portions adapted from LiveKit Agents
+ * (https://github.com/livekit/agents, commit
+ * 78a66bcf79c5cea82989401c408f1dff4b961a5b,
+ * file livekit-plugins/livekit-plugins-groq/livekit/plugins/groq/services.py),
+ * licensed under Apache License 2.0. Copyright LiveKit, Inc.
+ *
+ * Adaptations from the LiveKit source:
+ *   * Ported the Python ``groq.LLM`` subclass (which subclasses the
+ *     LiveKit OpenAI plugin) into a tiny TypeScript wrapper that swaps
+ *     the base URL and defaults to ``llama-3.3-70b-versatile``.
+ */
+
+interface GroqLLMOptions$1 {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}
+/** LLM provider backed by Groq's OpenAI-compatible Chat Completions API. */
+declare class GroqLLMProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
-    private readonly voice;
-    private readonly language;
-    private readonly format;
-    private readonly sampleRate;
-    private readonly temperature;
-    private readonly topP;
     private readonly baseUrl;
-    constructor(apiKey: string, opts?: LMNTTTSOptions);
-    private buildPayload;
-    synthesize(text: string): Promise<Buffer>;
-    /** Yield audio chunks as they arrive — raw PCM_S16LE by default. */
-    synthesizeStream(text: string): AsyncGenerator<Buffer>;
+    constructor(options: GroqLLMOptions$1);
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+
+/** Groq LLM for Patter pipeline mode. */
+
+interface GroqLLMOptions {
+    /** API key. Falls back to GROQ_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** Model id (e.g. ``"llama-3.3-70b-versatile"``). */
+    model?: string;
+    /** Override the OpenAI-compatible base URL (rarely needed). */
+    baseUrl?: string;
+}
+/**
+ * Groq LLM provider (OpenAI-compatible Chat Completions, streaming).
+ *
+ * @example
+ * ```ts
+ * import * as groq from "getpatter/llm/groq";
+ * const llm = new groq.LLM();                                // reads GROQ_API_KEY
+ * const llm = new groq.LLM({ apiKey: "gsk_...", model: "llama-3.3-70b-versatile" });
+ * ```
+ */
+declare class LLM$2 extends GroqLLMProvider {
+    constructor(opts?: GroqLLMOptions);
+}
+
+/**
+ * Cerebras LLM provider for Patter's pipeline mode.
+ *
+ * Cerebras exposes an OpenAI-compatible Chat Completions API at
+ * ``https://api.cerebras.ai/v1``. This provider reuses the OpenAI SSE
+ * parser from ``groq-llm.ts`` and optionally enables gzip request-body
+ * compression to reduce TTFT for requests with large prompts
+ * (see https://inference-docs.cerebras.ai/payload-optimization).
+ *
+ * Portions adapted from LiveKit Agents
+ * (https://github.com/livekit/agents, commit
+ * 78a66bcf79c5cea82989401c408f1dff4b961a5b,
+ * file livekit-plugins/livekit-plugins-cerebras/livekit/plugins/cerebras/llm.py),
+ * licensed under Apache License 2.0. Copyright 2026 LiveKit, Inc.
+ *
+ * Adaptations from the LiveKit source:
+ *   * LiveKit's ``cerebras.LLM`` subclasses the LiveKit OpenAI plugin.
+ *     Patter's analogue is a tiny wrapper around ``fetch`` that swaps
+ *     the base URL and default model.
+ *   * The msgpack payload optimisation from LiveKit is Python-only
+ *     (msgpack in Node land isn't as standard); only gzip compression
+ *     is ported. Enable with ``gzipCompression: true``.
+ */
+
+interface CerebrasLLMOptions$1 {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    /** Gzip request payloads for faster TTFT on large prompts. */
+    gzipCompression?: boolean;
+}
+/** LLM provider backed by Cerebras's OpenAI-compatible Inference API. */
+declare class CerebrasLLMProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly gzipCompression;
+    constructor(options: CerebrasLLMOptions$1);
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+
+/** Cerebras LLM for Patter pipeline mode. */
+
+interface CerebrasLLMOptions {
+    /** API key. Falls back to CEREBRAS_API_KEY env var when omitted. */
+    apiKey?: string;
+    /** Model id (e.g. ``"llama3.1-8b"``). */
+    model?: string;
+    /** Override the OpenAI-compatible base URL (rarely needed). */
+    baseUrl?: string;
+    /** Gzip request payloads for faster TTFT on large prompts. */
+    gzipCompression?: boolean;
+}
+/**
+ * Cerebras LLM provider (OpenAI-compatible Inference API, streaming).
+ *
+ * @example
+ * ```ts
+ * import * as cerebras from "getpatter/llm/cerebras";
+ * const llm = new cerebras.LLM();                              // reads CEREBRAS_API_KEY
+ * const llm = new cerebras.LLM({ apiKey: "csk-...", model: "llama3.1-8b" });
+ * ```
+ */
+declare class LLM$1 extends CerebrasLLMProvider {
+    constructor(opts?: CerebrasLLMOptions);
+}
+
+/**
+ * Google Gemini LLM provider for Patter's pipeline mode.
+ *
+ * Implements the ``LLMProvider`` interface against the Gemini Developer
+ * API's streaming endpoint (``:streamGenerateContent?alt=sse``).
+ * OpenAI-style messages/tools are translated into Gemini's ``contents``
+ * and ``tools`` shapes, and streamed response parts are normalised to
+ * Patter's ``{ type: 'text' | 'tool_call' | 'done' }`` chunks.
+ *
+ * Portions adapted from LiveKit Agents
+ * (https://github.com/livekit/agents, commit
+ * 78a66bcf79c5cea82989401c408f1dff4b961a5b,
+ * file livekit-plugins/livekit-plugins-google/livekit/plugins/google/llm.py),
+ * licensed under Apache License 2.0. Copyright 2023 LiveKit, Inc.
+ *
+ * Adaptations from the LiveKit source:
+ *   * LiveKit uses the ``google-genai`` Python SDK. The TypeScript port
+ *     uses native ``fetch`` against the REST SSE endpoint so we don't
+ *     pull in a large SDK dependency.
+ *   * Collapsed the Python ``llm.LLM`` / ``llm.LLMStream`` pair into a
+ *     single class that satisfies Patter's ``LLMProvider`` interface.
+ *   * Dropped Vertex AI support (which requires GCP auth) — only the
+ *     Developer API (API key) path is ported. Vertex can be added by a
+ *     follow-up PR once credential plumbing is in place.
+ */
+
+interface GoogleLLMOptions$1 {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    temperature?: number;
+    maxOutputTokens?: number;
+}
+/** LLM provider backed by Google Gemini (Developer API, streaming SSE). */
+declare class GoogleLLMProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly temperature?;
+    private readonly maxOutputTokens?;
+    constructor(options: GoogleLLMOptions$1);
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
+}
+
+/** Google Gemini LLM for Patter pipeline mode. */
+
+interface GoogleLLMOptions {
+    /**
+     * API key. Falls back to ``GEMINI_API_KEY`` first, then ``GOOGLE_API_KEY``.
+     * (Google's CLI tooling uses ``GEMINI_API_KEY``; ``GOOGLE_API_KEY`` is the
+     * legacy/alt name accepted for parity with other SDKs.)
+     */
+    apiKey?: string;
+    /** Model id (e.g. ``"gemini-2.5-flash"``). */
+    model?: string;
+    /** Override the Generative Language API base URL (rarely needed). */
+    baseUrl?: string;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Maximum output tokens. */
+    maxOutputTokens?: number;
+}
+/**
+ * Google Gemini LLM provider (Developer API, streaming SSE).
+ *
+ * @example
+ * ```ts
+ * import * as google from "getpatter/llm/google";
+ * const llm = new google.LLM();                                 // reads GEMINI_API_KEY or GOOGLE_API_KEY
+ * const llm = new google.LLM({ apiKey: "AIza...", model: "gemini-2.5-flash" });
+ * ```
+ */
+declare class LLM extends GoogleLLMProvider {
+    constructor(opts?: GoogleLLMOptions);
 }
 
 /**
@@ -2048,4 +2834,4 @@ declare class BackgroundAudioPlayer implements BackgroundAudioPlayer$1 {
     private resampleTo;
 }
 
-export { type Agent, type AgentOptions, AllProvidersFailedError, type AnthropicConversion, type AnthropicMessage, type AssemblyAIEncoding, type AssemblyAIModel, AssemblyAISTT, type AssemblyAISTTOptions, type AudioConfig, type AudioSource, AuthenticationError, type BackgroundAudioOptions, BackgroundAudioPlayer, BuiltinAudioClip, type BuiltinAudioClipName, type BuiltinPcmSource, type Call, type CallControl, type CallEventHandler, type CallMetrics, CallMetricsAccumulator, type CallOptions, type CallRecord, type CartesiaEncoding, CartesiaSTT, type CartesiaSTTOptions, CartesiaTTS, type CartesiaTTSOptions, ChatContext, type ChatMessage, type ChatRole, type ConnectOptions, type CostBreakdown, type CreateAgentOptions, DEFAULT_MIN_SENTENCE_LEN, DEFAULT_PRICING, DTMF_EVENTS, DeepgramSTT, type DefineToolInput, type DtmfEvent, ElevenLabsConvAIAdapter, ElevenLabsTTS, FallbackLLMProvider, type FallbackLLMProviderOptions, type FilePcmSource, GEMINI_DEFAULT_INPUT_SR, GEMINI_DEFAULT_OUTPUT_SR, GeminiLiveAdapter, type GeminiLiveEventHandler, type Guardrail, type HookContext, IVRActivity, type IVRActivityOptions, type IVRToolDefinition, type IncomingMessage, type JobCallback, type LLMChunk, LLMLoop, type LLMProvider, type LMNTAudioFormat, type LMNTModel, type LMNTSampleRate, LMNTTTS, type LMNTTTSOptions, type LatencyBreakdown, type LocalCallOptions, type LocalConfig, type LocalOptions, type Logger, type LoopCallback, type MessageHandler, MetricsStore, OpenAILLMProvider, type OpenAIMessage, OpenAIRealtimeAdapter, OpenAITTS, type ParamSpec, PartialStreamError, Patter, PatterConnectionError, PatterError, type PatterOptions, type PhoneNumber, PipelineHookExecutor, type PipelineHooks, type PipelineMessageHandler, type ProviderPricing, ProvisionError, type RawPcmSource, RemoteMessageHandler, RimeTTS, type RimeTTSOptions, type SSEEvent, type STTConfig, type ScheduleHandle, SentenceChunker, type ServeOptions, type SilenceCallback, SonioxSTT, type SonioxSTTOptions, type TTSConfig, TestSession, TfidfLoopDetector, type TfidfLoopDetectorOptions, type ToolDefinition, type TunnelHandle, type TurnMetrics, ULTRAVOX_DEFAULT_API_BASE, ULTRAVOX_DEFAULT_SR, type UltravoxEventHandler, UltravoxRealtimeAdapter, WhisperSTT, builtinClipPath, calculateRealtimeCost, calculateSttCost, calculateTelephonyCost, calculateTtsCost, callsToCsv, callsToJson, deepgram, defineTool, elevenlabs, filterEmoji, filterForTTS, filterMarkdown, formatDtmf, getLogger, isRemoteUrl, isWebSocketUrl, makeAuthMiddleware, mergePricing, mixPcm, mountApi, mountDashboard, mulawToPcm16, notifyDashboard, openaiTts, pcm16ToMulaw, resample16kTo8k, resample24kTo16k, resample8kTo16k, resamplePcm, scheduleCron, scheduleInterval, scheduleOnce, selectSoundFromList, setLogger, startTunnel, whisper };
+export { type Agent, type AgentOptions, AllProvidersFailedError, type AnthropicConversion, LLM$3 as AnthropicLLM, type AnthropicLLMOptions, type AnthropicMessage, type AssemblyAIEncoding, type AssemblyAIModel, STT as AssemblyAISTT, type AssemblyAISTTOptions, type AudioConfig, type AudioSource, AuthenticationError, type BackgroundAudioOptions, BackgroundAudioPlayer, BuiltinAudioClip, type BuiltinAudioClipName, type BuiltinPcmSource, type Call, type CallControl, type CallEventHandler, type CallMetrics, CallMetricsAccumulator, type CallOptions, type CallRecord, type CartesiaEncoding, STT$2 as CartesiaSTT, type CartesiaSTTOptions, TTS$2 as CartesiaTTS, type CartesiaTTSOptions, LLM$1 as CerebrasLLM, type CerebrasLLMOptions, ChatContext, type ChatMessage, type ChatRole, CloudflareTunnel, type ConnectOptions, type CostBreakdown, type CreateAgentOptions, DEFAULT_MIN_SENTENCE_LEN, DEFAULT_PRICING, DTMF_EVENTS, STT$4 as DeepgramSTT, type DeepgramSTTOptions, type DefineToolInput, type DtmfEvent, ConvAI as ElevenLabsConvAI, ElevenLabsConvAIAdapter, type ConvAIOptions as ElevenLabsConvAIOptions, TTS$4 as ElevenLabsTTS, type ElevenLabsTTSOptions, FallbackLLMProvider, type FallbackLLMProviderOptions, type FilePcmSource, GEMINI_DEFAULT_INPUT_SR, GEMINI_DEFAULT_OUTPUT_SR, GeminiLiveAdapter, type GeminiLiveEventHandler, LLM as GoogleLLM, type GoogleLLMOptions, LLM$2 as GroqLLM, type GroqLLMOptions, Guardrail$1 as Guardrail, type GuardrailOptions, type HookContext, IVRActivity, type IVRActivityOptions, type IVRToolDefinition, type IncomingMessage, type JobCallback, type LLMChunk, LLMLoop, type LLMProvider, type LMNTAudioFormat, type LMNTModel, type LMNTSampleRate, TTS as LMNTTTS, type LMNTTTSOptions, type LatencyBreakdown, type LocalCallOptions, type LocalConfig, type LocalOptions, type Logger, type LoopCallback, type MessageHandler, MetricsStore, LLM$4 as OpenAILLM, type OpenAILLMOptions, OpenAILLMProvider, type OpenAIMessage, Realtime as OpenAIRealtime, OpenAIRealtimeAdapter, type RealtimeOptions as OpenAIRealtimeOptions, TTS$3 as OpenAITTS, type OpenAITTSOptions, type ParamSpec, PartialStreamError, Patter, PatterConnectionError, PatterError, type PatterOptions, type PhoneNumber, PipelineHookExecutor, type PipelineHooks, type PipelineMessageHandler, type ProviderPricing, ProvisionError, type RawPcmSource, RemoteMessageHandler, TTS$1 as RimeTTS, type RimeTTSOptions, type SSEEvent, type STTConfig, type ScheduleHandle, SentenceChunker, type ServeOptions, type SilenceCallback, STT$1 as SonioxSTT, type SonioxSTTOptions$1 as SonioxSTTOptions, Static as StaticTunnel, type TTSConfig, Carrier as Telnyx, type TelnyxCarrierOptions, TestSession, TfidfLoopDetector, type TfidfLoopDetectorOptions, Tool, type ToolDefinition, type ToolHandler, type ToolOptions, type TunnelHandle, type TurnMetrics, Carrier$1 as Twilio, type TwilioCarrierOptions, ULTRAVOX_DEFAULT_API_BASE, ULTRAVOX_DEFAULT_SR, type UltravoxEventHandler, UltravoxRealtimeAdapter, STT$3 as WhisperSTT, type WhisperSTTOptions, builtinClipPath, calculateRealtimeCost, calculateSttCost, calculateTelephonyCost, calculateTtsCost, callsToCsv, callsToJson, deepgram, defineTool, elevenlabs, filterEmoji, filterForTTS, filterMarkdown, formatDtmf, getLogger, guardrail, isRemoteUrl, isWebSocketUrl, makeAuthMiddleware, mergePricing, mixPcm, mountApi, mountDashboard, mulawToPcm16, notifyDashboard, openaiTts, pcm16ToMulaw, resample16kTo8k, resample24kTo16k, resample8kTo16k, resamplePcm, scheduleCron, scheduleInterval, scheduleOnce, selectSoundFromList, setLogger, startTunnel, tool, whisper };