getpatter 0.4.3 → 0.5.0

package/dist/index.d.ts

@@ -1,6 +1,245 @@
 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>;
+}
+
 interface IncomingMessage {
     readonly text: string;
     readonly callId: string;
@@ -10,13 +249,21 @@ interface STTConfig {
     readonly provider: string;
     readonly apiKey: string;
     readonly language: string;
-    toDict(): Record<string, string>;
+    /**
+     * Optional — when present, called by internal serialisation. Not required for
+     * callers that pass a plain object literal (``{ provider, apiKey, language }``)
+     * to maintain parity with the Python SDK, which accepts dataclass-like inputs.
+     */
+    toDict?(): Record<string, string | Record<string, unknown>>;
+    /** Provider-specific knobs (e.g. Deepgram endpointing). */
+    options?: Record<string, unknown>;
 }
 interface TTSConfig {
     readonly provider: string;
     readonly apiKey: string;
     readonly voice: string;
-    toDict(): Record<string, string>;
+    toDict?(): Record<string, string | Record<string, unknown>>;
+    options?: Record<string, unknown>;
 }
 type MessageHandler = (msg: IncomingMessage) => Promise<string>;
 type CallEventHandler = (data: Record<string, unknown>) => Promise<void>;
@@ -99,20 +346,35 @@ interface Call {
     }> | null;
 }
 interface LocalOptions {
-    mode: 'local';
-    twilioSid?: string;
-    twilioToken?: string;
-    openaiKey?: string;
+    /**
+     * Local mode is auto-detected when a ``carrier`` is passed. Pass
+     * ``mode: 'local'`` to force local mode explicitly.
+     */
+    mode?: 'local';
+    /**
+     * Telephony carrier instance. Required for local mode.
+     *
+     * @example
+     * ```ts
+     * import { Patter, Twilio } from "getpatter";
+     * const phone = new Patter({ carrier: new Twilio(), phoneNumber: "+1..." });
+     * ```
+     */
+    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;
-    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.
+     * @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 }) })``.
      */
-    telnyxPublicKey?: string;
+    openaiKey?: string;
 }
 interface Guardrail {
     /** Name for logging when triggered */
@@ -168,23 +430,40 @@ 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;
     /** 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).
@@ -197,6 +476,13 @@ interface AgentOptions {
     audioFilter?: AudioFilter;
     /** Optional background audio mixer (hold music, thinking cues). Pipeline mode only. */
     backgroundAudio?: BackgroundAudioPlayer$1;
+    /**
+     * Minimum sustained voice (ms) before treating caller audio as a barge-in
+     * and interrupting TTS. `0` disables barge-in entirely — useful on noisy
+     * links (ngrok tunnels, speakerphone) where the agent can hear itself.
+     * Default: 300.
+     */
+    bargeInThresholdMs?: number;
 }
 type PipelineMessageHandler = (data: Record<string, unknown>) => Promise<string>;
 interface ServeOptions {
@@ -235,32 +521,22 @@ interface LocalCallOptions {
     voicemailMessage?: string;
     /** Dynamic variables merged into agent.variables before call. Override agent-level variables. */
     variables?: Record<string, string>;
+    /**
+     * Ring timeout in seconds. Forwarded to Twilio as `Timeout` and to Telnyx
+     * as `timeout_secs`. Defaults to the carrier default (~28 s on Twilio) when
+     * omitted. Increase for international routes where the remote carrier
+     * silences short US→IT rings.
+     */
+    ringTimeout?: number;
 }
 
-declare function deepgram(opts: {
-    apiKey: string;
-    language?: string;
-}): 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 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);
@@ -278,48 +554,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 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;
 }
 
@@ -492,6 +726,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.
  *
@@ -693,79 +955,92 @@ declare class ElevenLabsConvAIAdapter {
     close(): void;
 }
 
-interface Transcript$4 {
-    readonly text: string;
-    readonly isFinal: boolean;
-    readonly confidence: number;
-}
-type TranscriptCallback$4 = (transcript: Transcript$4) => void;
-declare class DeepgramSTT {
-    private readonly apiKey;
-    private readonly language;
-    private readonly model;
-    private readonly encoding;
-    private readonly sampleRate;
-    private ws;
-    private callbacks;
-    /** Request ID from Deepgram — used to query actual cost post-call. */
-    requestId: string;
-    constructor(apiKey: string, language?: string, model?: string, encoding?: string, sampleRate?: number);
-    /** Factory for Twilio calls — mulaw 8 kHz. */
-    static forTwilio(apiKey: string, language?: string, model?: string): 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.
+ * In-memory metrics store for the local dashboard.
  *
- * Buffers incoming PCM16 audio and periodically sends it to the
- * OpenAI Whisper transcription API as a WAV file.
+ * Keeps the last `maxCalls` completed calls and tracks active calls.
+ * Supports SSE event subscribers for real-time updates.
  */
-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;
-}
 
-/**
- * Remote message handler for B2B webhook and WebSocket integration.
- *
- * Allows onMessage to be a URL string instead of a callable:
- * - HTTP webhook: onMessage="https://api.customer.com/patter/message"
- * - WebSocket: onMessage="ws://localhost:9000/stream"
- */
-declare class RemoteMessageHandler {
-    private readonly webhookSecret;
+interface CallRecord {
+    call_id: string;
+    caller: string;
+    callee: string;
+    direction: string;
+    started_at: number;
+    ended_at?: number;
     /**
-     * @param webhookSecret Optional HMAC secret. When provided, outgoing webhook
-     *   requests include an `X-Patter-Signature` header so the receiver can
-     *   verify the payload originated from Patter.
+     * Current lifecycle state: ``initiated`` (pre-registered), ``ringing``,
+     * ``in-progress``, ``completed``, ``no-answer``, ``busy``, ``failed``,
+     * ``canceled``, or ``webhook_error``.
      */
-    constructor(webhookSecret?: string);
-    /**
+    status?: string;
+    transcript?: Array<{
+        role: string;
+        text: string;
+        timestamp: number;
+    }>;
+    turns?: unknown[];
+    metrics?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+interface SSEEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+declare class MetricsStore extends EventEmitter {
+    private readonly maxCalls;
+    private calls;
+    private activeCalls;
+    /**
+     * Accepts either a numeric ``maxCalls`` (legacy positional — matches the
+     * original TS API) or an options object ``{ maxCalls }`` to align with the
+     * Python SDK's keyword-argument style. Plain literals also work:
+     * ``new MetricsStore()`` / ``new MetricsStore(100)`` / ``new MetricsStore({ maxCalls: 100 })``.
+     */
+    constructor(maxCallsOrOpts?: number | {
+        maxCalls?: number;
+    });
+    private publish;
+    recordCallStart(data: Record<string, unknown>): void;
+    /**
+     * Pre-register an outbound call before any webhook fires. Lets the
+     * dashboard surface attempts that never reach media (no-answer, busy,
+     * carrier-rejected). Mirrors the Python ``record_call_initiated``.
+     */
+    recordCallInitiated(data: Record<string, unknown>): void;
+    /**
+     * Update the status of an active or completed call. Terminal states
+     * (completed, no-answer, busy, failed, canceled, webhook_error) move the
+     * row from active to completed so the UI freezes the live duration timer.
+     */
+    updateCallStatus(callId: string, status: string, extra?: Record<string, unknown>): void;
+    recordTurn(data: Record<string, unknown>): void;
+    recordCallEnd(data: Record<string, unknown>, metrics?: Record<string, unknown> | null): void;
+    getCalls(limit?: number, offset?: number): CallRecord[];
+    getCall(callId: string): CallRecord | null;
+    getActiveCalls(): CallRecord[];
+    getAggregates(): Record<string, unknown>;
+    getCallsInRange(fromTs?: number, toTs?: number): CallRecord[];
+    get callCount(): number;
+}
+
+/**
+ * Remote message handler for B2B webhook and WebSocket integration.
+ *
+ * Allows onMessage to be a URL string instead of a callable:
+ * - HTTP webhook: onMessage="https://api.customer.com/patter/message"
+ * - WebSocket: onMessage="ws://localhost:9000/stream"
+ */
+declare class RemoteMessageHandler {
+    private readonly webhookSecret;
+    /**
+     * @param webhookSecret Optional HMAC secret. When provided, outgoing webhook
+     *   requests include an `X-Patter-Signature` header so the receiver can
+     *   verify the payload originated from Patter.
+     */
+    constructor(webhookSecret?: string);
+    /**
      * Compute HMAC-SHA256 hex digest for the given body.
      */
     private signPayload;
@@ -800,50 +1075,6 @@ declare function isRemoteUrl(onMessage: unknown): onMessage is string;
 /** Check if a URL is a WebSocket URL. */
 declare function isWebSocketUrl(url: string): boolean;
 
-/**
- * In-memory metrics store for the local dashboard.
- *
- * Keeps the last `maxCalls` completed calls and tracks active calls.
- * Supports SSE event subscribers for real-time updates.
- */
-
-interface CallRecord {
-    call_id: string;
-    caller: string;
-    callee: string;
-    direction: string;
-    started_at: number;
-    ended_at?: number;
-    transcript?: Array<{
-        role: string;
-        text: string;
-        timestamp: number;
-    }>;
-    turns?: unknown[];
-    metrics?: Record<string, unknown> | null;
-    [key: string]: unknown;
-}
-interface SSEEvent {
-    type: string;
-    data: Record<string, unknown>;
-}
-declare class MetricsStore extends EventEmitter {
-    private readonly maxCalls;
-    private calls;
-    private activeCalls;
-    constructor(maxCalls?: number);
-    private publish;
-    recordCallStart(data: Record<string, unknown>): void;
-    recordTurn(data: Record<string, unknown>): void;
-    recordCallEnd(data: Record<string, unknown>, metrics?: Record<string, unknown> | null): void;
-    getCalls(limit?: number, offset?: number): CallRecord[];
-    getCall(callId: string): CallRecord | null;
-    getActiveCalls(): CallRecord[];
-    getAggregates(): Record<string, unknown>;
-    getCallsInRange(fromTs?: number, toTs?: number): CallRecord[];
-    get callCount(): number;
-}
-
 interface LocalConfig {
     twilioSid?: string;
     twilioToken?: string;
@@ -1009,6 +1240,27 @@ declare class FallbackLLMProvider implements LLMProvider {
     getAvailability(): ReadonlyArray<boolean>;
     /** Clears all background recovery timers. Call this when shutting down. */
     destroy(): void;
+    /**
+     * Async-friendly disposer. Parity with Python's ``FallbackLLMProvider.aclose()``
+     * — safe to call multiple times, returns a resolved Promise once all probe
+     * timers are cleared. Prefer this in async contexts so awaiting the
+     * shutdown integrates naturally with the owning lifecycle.
+     */
+    aclose(): Promise<void>;
+    /**
+     * Explicit-resource-management hook so callers can write
+     * ``await using fallback = new FallbackLLMProvider([...])`` and have
+     * background probe timers cleared automatically when the block exits.
+     * Mirrors Python's ``async with FallbackLLMProvider(...)``.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Stream only the text deltas, flattening the chunk envelope. Parity with
+     * Python's ``FallbackLLMProvider.complete_stream``. Tool-call and done
+     * markers are filtered out so callers can concatenate the yielded strings
+     * directly.
+     */
+    completeStream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<string, void, unknown>;
     stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null): AsyncGenerator<LLMChunk, void, unknown>;
     private tryProviders;
     private markUnavailable;
@@ -1159,12 +1411,33 @@ interface ScheduleHandle {
     cancel(): void;
     readonly pending: boolean;
 }
-/** Schedule ``callback`` on a cron expression (node-cron dialect). */
-declare function scheduleCron(cron: string, callback: JobCallback): Promise<ScheduleHandle>;
+/** Schedule ``callback`` on a cron expression (node-cron dialect).
+ *
+ * Returns a ``ScheduleHandle`` synchronously (parity with Python
+ * ``schedule_cron``). The handle is "pending" until the lazy ``node-cron``
+ * import resolves; cancelling the handle before then discards the pending
+ * job cleanly. If ``node-cron`` is not installed, the returned promise
+ * attached to ``.ready`` rejects with a helpful install message.
+ */
+declare function scheduleCron(cron: string, callback: JobCallback): ScheduleHandle;
 /** Schedule ``callback`` once at the given date. */
 declare function scheduleOnce(at: Date, callback: JobCallback): ScheduleHandle;
-/** Schedule ``callback`` every ``intervalMs`` milliseconds. */
-declare function scheduleInterval(intervalMs: number, callback: JobCallback): ScheduleHandle;
+/**
+ * Schedule ``callback`` on a recurring interval.
+ *
+ * Accepts either a millisecond number (legacy, matches the original TS API)
+ * or an object with ``seconds`` / ``intervalMs`` for parity with Python's
+ * ``schedule_interval(seconds=...)``.
+ *
+ * Examples:
+ *   scheduleInterval(5000, cb)              // 5 s, legacy
+ *   scheduleInterval({ intervalMs: 5000 }, cb)
+ *   scheduleInterval({ seconds: 5 }, cb)    // parity with Python
+ */
+declare function scheduleInterval(intervalOrOpts: number | {
+    seconds?: number;
+    intervalMs?: number;
+}, callback: JobCallback): ScheduleHandle;
 
 /**
  * Soniox Speech-to-Text adapter for Patter (TypeScript).
@@ -1184,13 +1457,13 @@ declare function scheduleInterval(intervalMs: number, callback: JobCallback): Sc
  * `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;
@@ -1218,7 +1491,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;
@@ -1227,7 +1500,7 @@ declare class SonioxSTT {
     private handleMessage;
     private emit;
     sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback$2): void;
+    onTranscript(callback: TranscriptCallback$4): void;
     close(): void;
 }
 
@@ -1242,15 +1515,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. */
@@ -1291,7 +1564,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;
@@ -1299,7 +1572,7 @@ declare class AssemblyAISTT {
     private handleEvent;
     private emit;
     sendAudio(audio: Buffer): void;
-    onTranscript(callback: TranscriptCallback$1): void;
+    onTranscript(callback: TranscriptCallback$3): void;
     close(): void;
 }
 
@@ -1314,15 +1587,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. */
@@ -1342,21 +1615,296 @@ 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;
+}
+
+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;
+    format?: LMNTAudioFormat;
+    sampleRate?: LMNTSampleRate;
+    temperature?: number;
+    topP?: number;
+    baseUrl?: string;
+}
+declare class LMNTTTS {
+    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$1);
+    private buildPayload;
+    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 voiceId;
     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.
@@ -1373,6 +1921,29 @@ declare class ElevenLabsTTS {
     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;
@@ -1389,19 +1960,48 @@ declare class OpenAITTS {
      *
      * 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>;
     /**
-     * Resample 24 kHz PCM16-LE to 16 kHz by taking 2 out of every 3 samples.
-     *
-     * For each group of 3 input samples the first is kept as-is and the second
-     * output sample is the average of input samples 2 and 3.  This matches the
-     * Python SDK implementation.
+     * 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 {
+/** 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;
@@ -1423,7 +2023,7 @@ declare class CartesiaTTS {
     private readonly volume?;
     private readonly baseUrl;
     private readonly apiVersion;
-    constructor(apiKey: string, opts?: CartesiaTTSOptions);
+    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. */
@@ -1435,7 +2035,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;
@@ -1466,7 +2095,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>;
     /**
@@ -1476,10 +2105,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;
@@ -1489,21 +2152,18 @@ interface LMNTTTSOptions {
     topP?: number;
     baseUrl?: string;
 }
-declare class LMNTTTS {
-    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>;
+/**
+ * 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);
 }
 
 /**
@@ -1867,4 +2527,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, 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, 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, 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, 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 };