getpatter 0.6.4 → 0.6.6

package/dist/index.d.mts

@@ -909,6 +909,9 @@ interface CallMetrics {
     readonly stt_model?: string;
     readonly tts_model?: string;
     readonly llm_model?: string;
+    /** Terminal error code when the call ended abnormally (a lowercased ErrorCode
+     * value or "other"); empty/absent for a clean call. Never the message. */
+    readonly error_code?: string;
 }
 /** Programmatic control surface for a live call (transfer, hangup, DTMF). */
 interface CallControl {
@@ -949,6 +952,7 @@ declare class CallMetricsAccumulator {
     readonly ttsModel: string;
     readonly realtimeModel: string;
     private readonly _pricing;
+    private _errorCode;
     private readonly _callStart;
     private readonly _turns;
     private _turnStart;
@@ -1259,6 +1263,12 @@ declare class CallMetricsAccumulator {
     recordLlmUsage(provider: string, model: string, inputTokens: number, outputTokens: number, cacheReadTokens?: number, cacheWriteTokens?: number): void;
     /** Finalize the call: flush any in-flight turn, compute aggregates, and return `CallMetrics`. */
     endCall(): CallMetrics;
+    /**
+     * Record the call's terminal error as a coarse, anonymous code. Stores the
+     * PatterError `.code` lowercased; maps common timeout/connection errors; falls
+     * back to "other". Never stores the message. Last write wins.
+     */
+    recordError(err: unknown): void;
     /** Return the cost breakdown for the call so far without ending it. */
     getCostSoFar(): CostBreakdown;
     /**
@@ -2254,6 +2264,29 @@ interface LLMChunk {
  */
 interface LLMStreamOptions {
     signal?: AbortSignal;
+    /**
+     * Stable per-call id (the same value the stream handler builds into
+     * ``callCtx.call_id``). Threaded through purely so session-aware providers
+     * — currently {@link OpenAICompatibleLLMProvider} and its Hermes / OpenClaw
+     * presets — can emit the OpenAI ``user`` field as ``patter-call-<callId>``,
+     * giving the upstream agent runtime one durable session per phone call.
+     *
+     * Additive and optional: every existing provider reads only ``signal`` and
+     * is unaffected. When unset (or when a provider has no session-continuity
+     * config) no ``user`` field is sent — fully backward compatible.
+     */
+    callId?: string;
+    /**
+     * Caller / callee for this turn (the same values the stream handler builds
+     * into ``callCtx.caller`` / ``callCtx.callee``). Threaded purely so a
+     * session-aware provider with a ``sessionKeyFactory`` can derive a per-caller
+     * memory scope from the NON-REVERSIBLE caller hash. Additive and optional:
+     * providers that read only ``signal`` / ``callId`` ignore them, and the raw
+     * ``caller`` is never logged. Mirrors the Python loop threading
+     * ``caller`` / ``callee`` into the provider's ``stream``.
+     */
+    caller?: string;
+    callee?: string;
 }
 interface LLMProvider {
     stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null, opts?: LLMStreamOptions): AsyncGenerator<LLMChunk, void, unknown>;
@@ -2807,6 +2840,18 @@ interface LocalOptions {
      * used via ``phone.agent({ engine: new OpenAIRealtime({ apiKey }) })``.
      */
     readonly openaiKey?: string;
+    /**
+     * Anonymous usage telemetry (opt-out, **on by default**). Lets the Patter
+     * maintainers see coarse, anonymous usage (engines/providers/carriers, OS,
+     * SDK version) — never PII or call content. Fire-and-forget and fail-safe.
+     *
+     * - omitted / ``true``: enabled (unless disabled by ``PATTER_TELEMETRY_DISABLED=1``,
+     *   ``DO_NOT_TRACK=1``, or a CI/test environment).
+     * - ``false``: opt out in code.
+     *
+     * Inspect-without-send with ``PATTER_TELEMETRY_DEBUG=1``. See the telemetry docs.
+     */
+    readonly telemetry?: boolean;
 }
 /** Internal shape of a guardrail (matches `Guardrail` class from `public-api.ts`). */
 interface Guardrail {
@@ -2924,6 +2969,28 @@ interface BackgroundAudioPlayer$1 {
  *    (see ``Patter.agent()`` for the resolution).
  * 3. Otherwise, the AgentOptions default is used.
  */
+/**
+ * Per-call context handed to a ``sessionKeyFactory`` (see
+ * {@link OpenAICompatibleLLMOptions.sessionKeyFactory}).
+ *
+ * A session-aware LLM provider (e.g. the Hermes preset) can derive its
+ * memory-scope header value per call from this — most usefully from
+ * {@link SessionContext.callerHash}, a stable non-reversible hash of the
+ * caller, so one phone number maps to one durable memory namespace across calls
+ * WITHOUT the raw number ever being emitted or logged.
+ *
+ * All fields are optional: ``callId`` / ``caller`` / ``callee`` are present when
+ * the call provides them; ``callerHash`` is {@link hashCaller} of ``caller``
+ * (``undefined`` when there is no caller). The raw ``caller`` is carried here
+ * only so a factory CAN re-derive its own scope — it must never be put on the
+ * wire or logged beyond what already exists. Mirrors Python ``SessionContext``.
+ */
+interface SessionContext {
+    readonly callId?: string;
+    readonly caller?: string;
+    readonly callee?: string;
+    readonly callerHash?: string;
+}
 /** Configuration for a local-mode voice AI agent (passed to `phone.agent({...})`). */
 interface AgentOptions {
     readonly systemPrompt: string;
@@ -2947,6 +3014,38 @@ interface AgentOptions {
      */
     readonly language?: string;
     readonly firstMessage?: string;
+    /**
+     * Opt-in spoken fallback for pipeline mode when the per-turn LLM stream
+     * throws (gateway-down / 120 s timeout) BEFORE any assistant text was
+     * spoken. Agent-runtime providers (Hermes / OpenClaw) run tools+memory
+     * internally so a turn can take 30-90 s; on failure the caller currently
+     * hears SILENCE then a silent turn-end. When set to a non-empty string,
+     * the SDK synthesizes and speaks this line through the normal TTS turn
+     * lifecycle (subject to barge-in). ``undefined`` (default) preserves
+     * today's behaviour: nothing is spoken on LLM error. Pipeline mode only.
+     * Mirrors Python ``llm_error_message`` on ``Patter.agent()`` / ``Agent``.
+     */
+    readonly llmErrorMessage?: string;
+    /**
+     * Opt-in short filler spoken when an LLM turn is SLOW (e.g. an agent runtime
+     * running tools / memory) and no audio has reached the carrier yet — DISTINCT
+     * from ``llmErrorMessage`` (which fires on an ERROR; this fires on SLOWNESS).
+     * When set to a non-empty string and the turn has produced NO audio after
+     * ``longTurnMessageAfterS`` seconds, the SDK synthesizes this line ONCE
+     * through the normal TTS turn lifecycle (subject to barge-in) to fill the
+     * gap. It never fires once real audio has started this turn, and never
+     * double-speaks. ``undefined`` (default) keeps today's behaviour: nothing is
+     * spoken while a slow turn runs. Pipeline mode only. Mirrors Python
+     * ``long_turn_message`` on ``Patter.agent()`` / ``Agent``.
+     */
+    readonly longTurnMessage?: string;
+    /**
+     * Seconds to wait after the turn begins speaking before the
+     * ``longTurnMessage`` filler fires (only consulted when ``longTurnMessage``
+     * is set and no audio has reached the carrier yet). Default ``4.0``. Mirrors
+     * Python ``long_turn_message_after_s``.
+     */
+    readonly longTurnMessageAfterS?: number;
     /** Tool definitions — ``Tool`` class instances from ``getpatter``. */
     readonly tools?: ReadonlyArray<Tool>;
     /**
@@ -3866,6 +3965,14 @@ declare class Patter {
      * ``Cannot use both tunnel: true and webhookUrl``.
      */
     private tunnelOwnsWebhookUrl;
+    /**
+     * Anonymous usage telemetry (opt-out, default ON). Separate from
+     * ``./observability`` (user-facing OTel). Fire-and-forget and fail-safe — it
+     * can never block or break a call. See ``./telemetry``.
+     */
+    private readonly telemetry;
+    private readonly telemetrySeenEngines;
+    private readonly telemetrySeenAgentShapes;
     /**
      * Pre-rendered first-message TTS audio per outbound call_id. Populated
      * by :meth:`call` when ``agent.prewarmFirstMessage`` is true; consumed
@@ -4940,6 +5047,7 @@ declare class PatterTool {
     private readonly maxDurationSec;
     private readonly recording;
     private started;
+    private hermesTelemetryEmitted;
     /** Cached in-progress (or completed) start promise so concurrent execute()
      *  callers all await the same boot sequence instead of each racing into
      *  phone.serve(). Reset to null on failure so callers can retry after a
@@ -6973,7 +7081,7 @@ interface OpenAILLMOptions {
  * const llm = new openai.LLM({ apiKey: "sk-...", model: "gpt-4o-mini", temperature: 0.4 });
  * ```
  */
-declare class LLM$4 extends OpenAILLMProvider {
+declare class LLM$8 extends OpenAILLMProvider {
     static readonly providerKey = "openai";
     constructor(opts?: OpenAILLMOptions);
 }
@@ -7084,7 +7192,7 @@ interface AnthropicLLMOptions {
  * const llm = new anthropic.LLM({ promptCaching: false });           // opt out of caching
  * ```
  */
-declare class LLM$3 extends AnthropicLLMProvider {
+declare class LLM$7 extends AnthropicLLMProvider {
     static readonly providerKey = "anthropic";
     constructor(opts?: AnthropicLLMOptions);
 }
@@ -7192,7 +7300,7 @@ interface GroqLLMOptions {
  * const llm = new groq.LLM({ apiKey: "gsk_...", model: "llama-3.3-70b-versatile" });
  * ```
  */
-declare class LLM$2 extends GroqLLMProvider {
+declare class LLM$6 extends GroqLLMProvider {
     static readonly providerKey = "groq";
     constructor(opts?: GroqLLMOptions);
 }
@@ -7337,7 +7445,7 @@ interface CerebrasLLMOptions {
  * const llm = new cerebras.LLM({ apiKey: "csk-...", model: "llama3.1-8b" });
  * ```
  */
-declare class LLM$1 extends CerebrasLLMProvider {
+declare class LLM$5 extends CerebrasLLMProvider {
     static readonly providerKey = "cerebras";
     constructor(opts?: CerebrasLLMOptions);
 }
@@ -7419,11 +7527,491 @@ interface GoogleLLMOptions {
  * const llm = new google.LLM({ apiKey: "AIza...", model: "gemini-2.5-flash" });
  * ```
  */
-declare class LLM extends GoogleLLMProvider {
+declare class LLM$4 extends GoogleLLMProvider {
     static readonly providerKey = "google";
     constructor(opts?: GoogleLLMOptions);
 }
 
+/**
+ * Generic OpenAI-compatible LLM provider for Patter's pipeline mode.
+ *
+ * Drives *any* OpenAI-compatible ``/chat/completions`` endpoint — an agent
+ * runtime (Hermes, OpenClaw) or a local inference gateway (Ollama, vLLM,
+ * LM Studio). Patter owns the carrier + STT + turn-taking + TTS; this
+ * provider turns each conversation turn into a single
+ * ``POST {baseUrl}/chat/completions`` request and speaks the response.
+ *
+ * PARITY NOTE (internal divergence, allowed by ``sdk-parity.md``): on the
+ * Python side this provider subclasses ``OpenAILLMProvider`` and merely swaps
+ * the ``AsyncOpenAI`` client (passing ``timeout=`` / ``base_url=``). The TS
+ * base ``OpenAILLMProvider`` is a raw-``fetch`` class with a HARDCODED 30 s
+ * timeout and ``baseUrl`` exposed as a ``protected get`` rather than a
+ * constructor field, so the "swap the client" trick is impossible here.
+ * Instead this is a STANDALONE ``implements LLMProvider`` class (same shape as
+ * {@link GroqLLMProvider} / {@link CerebrasLLMProvider}) that owns its own
+ * configurable timeout and reuses {@link parseOpenAISseStream}. Observably
+ * identical to Python (same 60 s / 120 s ceilings, same ``user`` field, same
+ * headers); only the timeout *mechanism* differs.
+ *
+ * Two additions over the base OpenAI provider:
+ *
+ * - **Long timeout.** Agent runtimes execute tools / memory / skills before
+ *   replying, so a turn can take 30-90 s. The default is 60 s here (the
+ *   presets raise it to 120 s), REPLACING the base provider's hardcoded 30 s.
+ * - **Session continuity.** Three independent, opt-in signals — each gated on
+ *   its own config, none coupled to another:
+ *     - ``sessionUserPrefix`` → emits the OpenAI ``user`` field as
+ *       ``` `${sessionUserPrefix}${callId}` ```. Used by runtimes that derive
+ *       a session from ``user`` (e.g. OpenClaw's gateway).
+ *     - ``sessionIdHeader`` (+ optional ``sessionIdPrefix``) → emits a per-call
+ *       header carrying ``` `${sessionIdPrefix}${callId}` ``` for per-call
+ *       session / transcript continuity on stateless runtimes that key off
+ *       headers (e.g. Hermes' ``X-Hermes-Session-Id``).
+ *     - ``sessionKeyHeader`` (+ ``sessionKey``) → emits a STATIC header for
+ *       long-term memory scoping (e.g. Hermes' ``X-Hermes-Session-Key``); the
+ *       value is the raw ``sessionKey``, never interpolated with the call id.
+ *   All three are OFF by default — fully backward compatible. ``sessionKey`` is
+ *   a credential-grade memory scope and is NEVER logged.
+ *
+ * Keyless gateways (Ollama / vLLM / LM Studio accept no key) are supported:
+ * the ``Authorization`` header is simply omitted from the request (sending a
+ * ``Bearer EMPTY`` placeholder breaks some gateways).
+ */
+
+/**
+ * Stable, non-reversible 16-char hash of a caller for session scoping.
+ *
+ * Used to derive a per-caller memory namespace (e.g. an agent runtime's session
+ * key) WITHOUT ever exposing the raw phone number — the call site keys cross-
+ * call memory off the hash, never the number itself. Returns the first 16 hex
+ * chars of the SHA-256 digest of the UTF-8 ``caller`` string, or ``undefined``
+ * when ``caller`` is undefined / empty. The 16-char (64-bit) truncation is
+ * plenty for namespacing while keeping the emitted header value compact; it is
+ * NOT a security primitive (a phone number has too little entropy to make the
+ * digest a secret) — its only job is to keep the raw number off the wire / out
+ * of logs. Mirrors Python ``hash_caller``.
+ */
+declare function hashCaller(caller?: string): string | undefined;
+/** Constructor options for {@link OpenAICompatibleLLMProvider}. */
+interface OpenAICompatibleLLMOptions {
+    /**
+     * Bearer token. If omitted and ``apiKeyEnv`` is given, read from that
+     * environment variable. May resolve to undefined for keyless local
+     * gateways — the ``Authorization`` header is then omitted entirely.
+     */
+    apiKey?: string;
+    /**
+     * Environment variable to read the bearer from when ``apiKey`` is not given
+     * (e.g. ``"OPENCLAW_API_KEY"``).
+     */
+    apiKeyEnv?: string;
+    /**
+     * OpenAI-compatible base URL ending in ``/v1`` — the whole point of this
+     * provider, so it is **required**. Operator-controlled config, never derived
+     * from caller / transcript input.
+     */
+    baseUrl: string;
+    /** Model / agent target — **required**. */
+    model: string;
+    /**
+     * Per-request timeout in **seconds**. Default ``60`` (the base OpenAI
+     * provider hardcodes 30 s — raised here because agent runtimes run tools
+     * before replying). Converted to ``AbortSignal.timeout(timeout * 1000)``.
+     */
+    timeout?: number;
+    /**
+     * Extra headers merged into the request *after* the ``User-Agent`` so the
+     * SDK attribution is not silently clobbered (a caller can still override
+     * ``User-Agent`` explicitly).
+     */
+    extraHeaders?: Record<string, string>;
+    /**
+     * When set, emits the OpenAI ``user`` field as
+     * ``` `${sessionUserPrefix}${callId}` ``` for per-call session continuity.
+     * ``undefined`` (default) means no ``user`` field is sent. Independent of the
+     * session headers below.
+     */
+    sessionUserPrefix?: string;
+    /**
+     * Optional header NAME carrying a per-call session id, e.g.
+     * ``"X-Hermes-Session-Id"`` or ``"x-openclaw-session-key"``. When set AND a
+     * ``callId`` is available, the header VALUE is
+     * ``` `${sessionIdPrefix}${callId}` ```. ``undefined`` (default) means off.
+     */
+    sessionIdHeader?: string;
+    /**
+     * Prefix for the session-id header VALUE. Defaults to ``""`` (raw call id).
+     * Only meaningful when ``sessionIdHeader`` is set.
+     */
+    sessionIdPrefix?: string;
+    /**
+     * Optional STATIC header NAME for long-term memory scoping, e.g.
+     * ``"X-Hermes-Session-Key"``. Emitted with the raw ``sessionKey`` value (no
+     * call-id interpolation) only when BOTH ``sessionKeyHeader`` and
+     * ``sessionKey`` are set. ``undefined`` (default) means off.
+     */
+    sessionKeyHeader?: string;
+    /**
+     * Static value emitted in ``sessionKeyHeader``. Credential-grade memory
+     * scope — NEVER logged. ``undefined`` (default) means the header is omitted.
+     */
+    sessionKey?: string;
+    /**
+     * Optional callback that derives the ``sessionKeyHeader`` VALUE per call from
+     * a {@link SessionContext} (carrying ``callId`` / ``caller`` / ``callee`` /
+     * ``callerHash``). When set it takes PRECEDENCE over the static ``sessionKey``:
+     * at request-build time the factory is called and its return value is emitted
+     * in ``sessionKeyHeader``. A falsy return (``undefined`` / ``''``) omits the
+     * header for that call. The static ``sessionKey`` remains the simple fallback
+     * used when no factory is configured. The returned value is a credential-grade
+     * memory scope and is NEVER logged. Mirrors Python ``session_key_factory``.
+     */
+    sessionKeyFactory?: (ctx: SessionContext) => string | undefined;
+    /**
+     * Convenience selector for a built-in per-call key derivation (requires
+     * ``sessionKeyHeader``). Set to ``'caller_hash'`` to derive the session key
+     * per call as ``` `patter-caller-${ctx.callerHash}` ``` (a stable,
+     * non-reversible hash of the caller — never the raw number), enabling
+     * per-caller cross-call memory on any runtime that scopes memory by header.
+     * ``undefined`` (default) uses the static ``sessionKey`` path. Ignored when
+     * ``sessionKeyFactory`` is given explicitly. Same semantics as the Hermes
+     * preset's selector; mirrors Python ``session_key_from``.
+     */
+    sessionKeyFrom?: 'caller_hash';
+    /** Sampling temperature [0, 2]. */
+    temperature?: number;
+    /** Max tokens in the assistant response (sent as ``max_completion_tokens``). */
+    maxTokens?: number;
+    /** OpenAI-style ``response_format`` for JSON mode / structured outputs. */
+    responseFormat?: Record<string, unknown>;
+    /** Whether to allow parallel tool calls. */
+    parallelToolCalls?: boolean;
+    /** ``"auto" | "none" | "required"`` or a specific tool object. */
+    toolChoice?: string | Record<string, unknown>;
+    /** Sampling seed for reproducible outputs. */
+    seed?: number;
+    /** Nucleus sampling cutoff in [0, 1]. */
+    topP?: number;
+    /** Penalty in [-2, 2] applied to repeated tokens. */
+    frequencyPenalty?: number;
+    /** Penalty in [-2, 2] applied to seen tokens. */
+    presencePenalty?: number;
+    /** Stop sequence(s). */
+    stop?: string | string[];
+}
+/**
+ * LLM provider for any OpenAI-compatible ``/chat/completions`` endpoint.
+ *
+ * Streams in the same ``{ type: "text" | "tool_call" | "usage" }`` chunk
+ * format as the base OpenAI provider via the shared {@link parseOpenAISseStream}.
+ */
+declare class OpenAICompatibleLLMProvider implements LLMProvider {
+    /**
+     * Stable pricing/dashboard key — read by stream-handler/metrics. Typed as
+     * ``string`` (not the narrowed literal) so the Hermes / OpenClaw presets can
+     * override it with their own key while still extending this class.
+     */
+    static readonly providerKey: string;
+    /** Resolved bearer; undefined for keyless gateways. */
+    private readonly apiKey?;
+    readonly model: string;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly extraHeaders?;
+    private readonly sessionUserPrefix?;
+    private readonly sessionIdHeader?;
+    private readonly sessionIdPrefix?;
+    private readonly sessionKeyHeader?;
+    private readonly sessionKey?;
+    private readonly sessionKeyFactory?;
+    private readonly temperature?;
+    private readonly maxTokens?;
+    private readonly responseFormat?;
+    private readonly parallelToolCalls?;
+    private readonly toolChoice?;
+    private readonly seed?;
+    private readonly topP?;
+    private readonly frequencyPenalty?;
+    private readonly presencePenalty?;
+    private readonly stop?;
+    constructor(options: OpenAICompatibleLLMOptions);
+    /**
+     * Assemble the request headers. ``User-Agent`` is set first so any
+     * ``extraHeaders`` (and the per-call session headers) layer on top without
+     * silently dropping the SDK attribution, and the ``Authorization`` header is
+     * only added when a key is present (keyless gateways omit it).
+     *
+     * The two session headers are emitted INDEPENDENTLY, each gated on its own
+     * config (decoupled from ``sessionUserPrefix`` and from each other):
+     *  - ``sessionIdHeader`` (+ ``callId``) → ``` `${sessionIdPrefix}${callId}` ```
+     *  - ``sessionKeyHeader`` (+ ``sessionKey``) → the static ``sessionKey`` value.
+     * ``sessionKey`` is a credential-grade memory scope and is never logged.
+     */
+    private buildHeaders;
+    /**
+     * Resolve the ``sessionKeyHeader`` VALUE for this call. When a
+     * ``sessionKeyFactory`` is configured it is called with a
+     * {@link SessionContext} (the raw ``caller`` plus its non-reversible
+     * {@link hashCaller}) and its return value wins — a falsy return omits the
+     * header. Otherwise the static ``sessionKey`` is used. Never logged.
+     */
+    private resolveSessionKey;
+    /**
+     * Pre-call DNS / TLS warmup for the configured endpoint. Best-effort:
+     * 5 s timeout, all exceptions swallowed at debug level. The ``Authorization``
+     * header is only sent when a key is present so the operator-grade bearer is
+     * never echoed for keyless gateways (and the key is never logged).
+     */
+    warmup(): Promise<void>;
+    /**
+     * Build the request body. Mirrors the base OpenAI provider's sampling-kwarg
+     * assembly and additionally sets ``user`` for session continuity when
+     * ``sessionUserPrefix`` is set AND a ``callId`` is available — so the default
+     * (prefix unset) behaviour is byte-identical to the base provider.
+     */
+    private buildBody;
+    /** Stream Patter-format LLM chunks from the configured chat completions API. */
+    stream(messages: Array<Record<string, unknown>>, tools?: Array<Record<string, unknown>> | null, opts?: LLMStreamOptions): AsyncGenerator<LLMChunk, void, unknown>;
+}
+/**
+ * Public alias of {@link OpenAICompatibleLLMProvider} for the
+ * ``getpatter/llm/openai-compatible`` namespace.
+ *
+ * @example
+ * ```ts
+ * import * as openaiCompatible from "getpatter/llm/openai-compatible";
+ * // Ollama / vLLM / LM Studio (keyless local gateway):
+ * const llm = new openaiCompatible.LLM({
+ *   baseUrl: "http://127.0.0.1:11434/v1",
+ *   model: "llama3.1",
+ * });
+ * ```
+ */
+declare class LLM$3 extends OpenAICompatibleLLMProvider {
+    static readonly providerKey = "openai_compatible";
+}
+
+/**
+ * Custom LLM — point Patter's pipeline at ANY OpenAI-compatible endpoint.
+ *
+ * The industry-standard "Custom LLM" pattern (the same concept ElevenLabs
+ * Agents, Retell, and Vapi expose under that name): Patter owns the phone leg
+ * — carrier, STT, turn-taking, barge-in, TTS — and POSTs each conversation
+ * turn to YOUR ``/chat/completions`` endpoint. That endpoint can be:
+ *
+ * - an **agent runtime** (Hermes, OpenClaw — prefer the dedicated presets in
+ *   ``llm/hermes`` / ``llm/openclaw``, thin subclasses of this same engine
+ *   with the right defaults baked in),
+ * - a **local inference gateway** (Ollama, vLLM, LM Studio — keyless OK),
+ * - or **your own service** that speaks the OpenAI Chat Completions protocol
+ *   (SSE streaming, optional tool calls).
+ *
+ * ``CustomLLM`` is the canonical name for the generic engine
+ * ({@link OpenAICompatibleLLMProvider}): same streaming loop, same barge-in
+ * cancellation, same opt-in session continuity (per-call ``user`` field,
+ * per-call session-id header, and a static or factory-derived memory-scope
+ * header).
+ *
+ * @example
+ * ```ts
+ * import { CustomLLM } from "getpatter";
+ *
+ * // Your own agent service (any OpenAI-compatible /chat/completions):
+ * const llm = new CustomLLM({
+ *   baseUrl: "http://127.0.0.1:9000/v1",
+ *   model: "my-agent",
+ *   apiKeyEnv: "MY_AGENT_KEY",
+ *   timeout: 120,                  // agent runtimes run tools before replying
+ * });
+ *
+ * // Keyless local gateway (Ollama / vLLM / LM Studio):
+ * const llm = new CustomLLM({ baseUrl: "http://127.0.0.1:11434/v1", model: "llama3.1" });
+ *
+ * // Per-call session continuity + per-caller long-term memory, on a runtime
+ * // that scopes sessions/memory by header:
+ * const llm = new CustomLLM({
+ *   baseUrl: "http://127.0.0.1:9000/v1",
+ *   model: "my-agent",
+ *   sessionIdHeader: "X-My-Session-Id",   // value = `${prefix}${callId}`
+ *   sessionIdPrefix: "patter-call-",
+ *   sessionKeyHeader: "X-My-Memory-Key",
+ *   sessionKeyFrom: "caller_hash",        // patter-caller-<hash>
+ * });
+ * ```
+ */
+
+/** Constructor options for the generic Custom LLM provider. */
+type CustomLLMOptions = OpenAICompatibleLLMOptions;
+/**
+ * Generic "Custom LLM" provider for any OpenAI-compatible endpoint.
+ *
+ * All constructor options are inherited from
+ * {@link OpenAICompatibleLLMOptions} (``baseUrl`` and ``model`` are
+ * required). The Hermes / OpenClaw presets are subclasses of the same engine
+ * — use them when they exist; use this for everything else.
+ */
+declare class LLM$2 extends OpenAICompatibleLLMProvider {
+    /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+    static readonly providerKey: string;
+}
+
+/**
+ * Hermes agent-runtime LLM preset for Patter's pipeline mode.
+ *
+ * Thin preset over {@link OpenAICompatibleLLMProvider}: defaults the base URL,
+ * model, env-key name, timeout, and session-continuity prefix for the Hermes
+ * agent runtime so a user just writes ``phone.agent({ llm: new hermes.LLM() })``.
+ *
+ * Hermes runs tools / memory / skills internally before replying, so a single
+ * conversation turn can take 30-90 s — hence the 120 s default timeout. Hermes
+ * is stateless and keys continuity off HEADERS, not the OpenAI ``user`` field:
+ * the preset sends ``X-Hermes-Session-Id: patter-call-<callId>`` on every turn
+ * for per-call session / transcript continuity (on by default), and optionally
+ * ``X-Hermes-Session-Key: <sessionKey>`` for long-term memory scoping when you
+ * pass ``sessionKey``. (It also still emits ``user=patter-call-<callId>`` for
+ * upstream-log correlation, but that is not what drives the session.)
+ */
+
+/** Constructor options for the Hermes ``LLM`` preset. */
+interface HermesLLMOptions {
+    /** Bearer token. Falls back to ``API_SERVER_KEY`` env var when omitted. */
+    apiKey?: string;
+    /** Override the Hermes base URL (rarely needed). */
+    baseUrl?: string;
+    /** Model id. Falls back to ``API_SERVER_MODEL_NAME`` env, then ``"hermes-agent"``. */
+    model?: string;
+    /** Per-request timeout in seconds. Default ``120``. */
+    timeout?: number;
+    /**
+     * Static long-term memory scope. When set, emits ``X-Hermes-Session-Key`` so
+     * Hermes scopes durable memory to this value across calls. ``undefined``
+     * (default) means the header is not sent. Credential-grade — never logged.
+     */
+    sessionKey?: string;
+    /**
+     * Convenience selector for a built-in per-call key derivation. Set to
+     * ``'caller_hash'`` to derive the session key per call as
+     * ``` `patter-caller-${ctx.callerHash}` ``` (a stable, non-reversible hash of
+     * the caller — never the raw number), enabling per-caller cross-call memory.
+     * ``undefined`` (default) uses the static ``sessionKey`` path. Ignored when
+     * ``sessionKeyFactory`` is given explicitly. Mirrors Python
+     * ``session_key_from``.
+     */
+    sessionKeyFrom?: 'caller_hash';
+    /**
+     * Custom callback deriving the ``X-Hermes-Session-Key`` value per call from a
+     * {@link SessionContext}. Takes precedence over both ``sessionKey`` and
+     * ``sessionKeyFrom``. A falsy return omits the header for that call.
+     * Credential-grade — never logged. Mirrors Python ``session_key_factory``.
+     */
+    sessionKeyFactory?: (ctx: SessionContext) => string | undefined;
+    /** Extra headers merged after the SDK ``User-Agent``. */
+    extraHeaders?: Record<string, string>;
+    /** Sampling temperature [0, 2]. */
+    temperature?: number;
+    /** Max tokens in the assistant response (sent as ``max_completion_tokens``). */
+    maxTokens?: number;
+    /** OpenAI-style ``response_format`` for JSON mode / structured outputs. */
+    responseFormat?: Record<string, unknown>;
+    /** Whether to allow parallel tool calls. */
+    parallelToolCalls?: boolean;
+    /** ``"auto" | "none" | "required"`` or a specific tool object. */
+    toolChoice?: string | Record<string, unknown>;
+    /** Sampling seed for reproducible outputs. */
+    seed?: number;
+    /** Nucleus sampling cutoff in [0, 1]. */
+    topP?: number;
+    /** Penalty in [-2, 2] applied to repeated tokens. */
+    frequencyPenalty?: number;
+    /** Penalty in [-2, 2] applied to seen tokens. */
+    presencePenalty?: number;
+    /** Stop sequence(s). */
+    stop?: string | string[];
+}
+/**
+ * Hermes agent-runtime LLM provider (OpenAI-compatible, streaming).
+ *
+ * @example
+ * ```ts
+ * import * as hermes from "getpatter/llm/hermes";
+ * const llm = new hermes.LLM();                       // env-defaulted, keyless OK
+ * const llm = new hermes.LLM({ apiKey: "...", model: "hermes-7b" });
+ * ```
+ */
+declare class LLM$1 extends OpenAICompatibleLLMProvider {
+    static readonly providerKey = "hermes";
+    constructor(opts?: HermesLLMOptions);
+}
+
+/**
+ * OpenClaw agent-runtime LLM preset for Patter's pipeline mode.
+ *
+ * Thin preset over {@link OpenAICompatibleLLMProvider}, aligned with the
+ * shipped ``openclawConsult`` builder in ``src/consult.ts``: same loopback
+ * base URL (``:18789/v1``), same ``OPENCLAW_API_KEY`` env var, same
+ * ``model="openclaw/<agent>"`` pass-through convention, same agent-id charset
+ * rule, and the same ``x-openclaw-session-key`` session header. Takes an
+ * ``agent`` id (not a raw model string), exactly like ``openclawConsult``.
+ *
+ * OpenClaw runs tools / memory / skills internally before replying, so a turn
+ * can take 30-90 s — hence the 120 s default timeout (unlike the consult
+ * preset's phone-safe 30 s filler default; here the runtime IS the per-turn
+ * brain, not an on-demand escalation). It keys sessions off BOTH the OpenAI
+ * ``user`` field and the ``x-openclaw-session-key`` header, so the preset
+ * enables both for one runtime session per phone call.
+ */
+
+/** Constructor options for the OpenClaw ``LLM`` preset. */
+interface OpenClawLLMOptions {
+    /**
+     * OpenClaw agent id (e.g. ``"receptionist"``). Mapped to
+     * ``model="openclaw/<agent>"``; an already-namespaced id (``"openclaw/x"``,
+     * ``"agent:x"``) is passed through unchanged. **Required.**
+     */
+    agent: string;
+    /** Override the OpenClaw base URL (rarely needed). */
+    baseUrl?: string;
+    /** Bearer token. Falls back to ``OPENCLAW_API_KEY`` env var when omitted. */
+    apiKey?: string;
+    /** Per-request timeout in seconds. Default ``120``. */
+    timeout?: number;
+    /** Extra headers merged after the SDK ``User-Agent``. */
+    extraHeaders?: Record<string, string>;
+    /** Sampling temperature [0, 2]. */
+    temperature?: number;
+    /** Max tokens in the assistant response (sent as ``max_completion_tokens``). */
+    maxTokens?: number;
+    /** OpenAI-style ``response_format`` for JSON mode / structured outputs. */
+    responseFormat?: Record<string, unknown>;
+    /** Whether to allow parallel tool calls. */
+    parallelToolCalls?: boolean;
+    /** ``"auto" | "none" | "required"`` or a specific tool object. */
+    toolChoice?: string | Record<string, unknown>;
+    /** Sampling seed for reproducible outputs. */
+    seed?: number;
+    /** Nucleus sampling cutoff in [0, 1]. */
+    topP?: number;
+    /** Penalty in [-2, 2] applied to repeated tokens. */
+    frequencyPenalty?: number;
+    /** Penalty in [-2, 2] applied to seen tokens. */
+    presencePenalty?: number;
+    /** Stop sequence(s). */
+    stop?: string | string[];
+}
+/**
+ * OpenClaw agent-runtime LLM provider (OpenAI-compatible, streaming).
+ *
+ * @example
+ * ```ts
+ * import * as openclaw from "getpatter/llm/openclaw";
+ * const llm = new openclaw.LLM({ agent: "receptionist" }); // reads OPENCLAW_API_KEY
+ * ```
+ */
+declare class LLM extends OpenAICompatibleLLMProvider {
+    static readonly providerKey = "openclaw";
+    constructor(opts: OpenClawLLMOptions);
+}
+
 /**
  * Silero VAD provider.
  *
@@ -8829,4 +9417,17 @@ interface CallEvent {
     readonly direction?: string;
 }
 
-export { type AgentOptions, type AgentState, AllProvidersFailedError, type AnthropicConversion, LLM$3 as AnthropicLLM, type AnthropicLLMOptions, type AnthropicMessage, AssemblyAIEncoding, AssemblyAIModel, STT$1 as AssemblyAISTT, type AssemblyAISTTOptions, type AudioConfig, type AudioSource, AuthenticationError, type BackgroundAudioOptions, BackgroundAudioPlayer, type EvaluateContext as BargeInEvaluateContext, type BargeInStrategy, BuiltinAudioClip, type BuiltinAudioClipName, type BuiltinPcmSource, type CallControl, type CallEvent, type CallEventHandler, type CallMetrics, CallMetricsAccumulator, type CallOutcome, type CallRecord, type CallResult, type CarrierKind, type CartesiaEncoding, STT$3 as CartesiaSTT, type CartesiaSTTOptions, TTS$3 as CartesiaTTS, CartesiaTTSModel, type CartesiaTTSOptions, CartesiaTTSVoiceMode, LLM$1 as CerebrasLLM, type CerebrasLLMOptions, ChatContext, type ChatMessage, type ChatRole, CloudflareTunnel, type ConsultConfig, type ConversationStateSnapshot, type CostBreakdown, DEFAULT_MIN_SENTENCE_LEN, DEFAULT_PRICING, DTMF_EVENTS, DeepFilterNetFilter, type DeepFilterNetOptions, DeepgramModel, STT$6 as DeepgramSTT, type DeepgramSTTOptions, DefaultToolExecutor, type DefaultToolExecutorOptions, type DefineToolInput, type DtmfEvent, ConvAI as ElevenLabsConvAI, ElevenLabsConvAIAdapter, type ConvAIOptions as ElevenLabsConvAIOptions, ElevenLabsModel, ElevenLabsOutputFormat, ElevenLabsTTS as ElevenLabsRestTTS, TTS$6 as ElevenLabsTTS, type ElevenLabsTTSOptions, type ElevenLabsWebSocketOptions, TTS$5 as ElevenLabsWebSocketTTS, type EouTrigger, ErrorCode, EventBus, 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 InitTracingOptions, TTS as InworldTTS, type InworldTTSOptions, type JobCallback, KrispFrameDuration, KrispSampleRate, KrispVivaFilter, type KrispVivaFilterOptions, type LLMChunk, LLMLoop, type LLMProvider, LMNTAudioFormat, LMNTModel, LMNTSampleRate, TTS$1 as LMNTTTS, type LMNTTTSOptions, type LatencyBreakdown, type LocalCallOptions, type LocalConfig, type LocalOptions, type Logger, type LoopCallback, type MessageHandler, MetricsStore, MinWordsStrategy, type MinWordsStrategyOptions, type ModelPricing, Ngrok, type OpenAICompatibleConsult, LLM$4 as OpenAILLM, type OpenAILLMOptions, OpenAILLMProvider, type OpenAIMessage, Realtime as OpenAIRealtime, Realtime2 as OpenAIRealtime2, OpenAIRealtime2Adapter, type Realtime2Options as OpenAIRealtime2Options, OpenAIRealtimeAdapter, OpenAIRealtimeAudioFormat, OpenAIRealtimeModel, type RealtimeOptions as OpenAIRealtimeOptions, OpenAIRealtimeVADType, TTS$4 as OpenAITTS, type OpenAITTSOptions, STT$4 as OpenAITranscribeSTT, type OpenAITranscribeSTTOptions, OpenAITranscriptionModel, OpenAIVoice, PRICING_LAST_UPDATED, PRICING_VERSION, type ParamSpec, PartialStreamError, Patter, PatterConfigError, PatterConnectionError, PatterError, type PatterEventType, PatterTool, type PatterToolExecuteArgs, type PatterToolOptions, type PatterToolResult, PcmCarry, PipelineHookExecutor, type PipelineHooks, type PipelineMessageHandler, Carrier as Plivo, PlivoAdapter, type PlivoCarrierOptions, type InitiateCallOptions as PlivoInitiateCallOptions, type InitiateCallResult as PlivoInitiateCallResult, PricingUnit, type PricingUnitValue, type ProviderPricing, ProvisionError, RateLimitError, type RawPcmSource, type RealtimeConfig, type RealtimeTurnDetection, RemoteMessageHandler, RimeAudioFormat, RimeModel, TTS$2 as RimeTTS, type RimeTTSOptions, SPAN_BARGEIN, SPAN_CALL, SPAN_ENDPOINT, SPAN_LLM, SPAN_STT, SPAN_TOOL, SPAN_TTS, type SSEEvent, type STTConfig, type ScheduleHandle, SentenceChunker, type ServeOptions, type SilenceCallback, type SileroSampleRate, SileroVAD, type SileroVADOptions, STT$2 as SonioxSTT, type SonioxSTTOptions$1 as SonioxSTTOptions, type Span, type SpeechEventCallback, SpeechEvents, SpeechmaticsAudioEncoding, SpeechmaticsOperatingPoint, STT as SpeechmaticsSTT, type SpeechmaticsSTTOptions, SpeechmaticsSampleRate, SpeechmaticsServerMessage, TurnDetectionMode as SpeechmaticsTurnDetectionMode, StatefulResampler, type StatefulResamplerOptions, Static as StaticTunnel, type TTSConfig, Carrier$1 as Telnyx, TelnyxAdapter, type TelnyxCarrierOptions, type ConfigureNumberOptions as TelnyxConfigureNumberOptions, type EndCallOptions as TelnyxEndCallOptions, type InitiateCallOptions$1 as TelnyxInitiateCallOptions, type InitiateCallResult$1 as TelnyxInitiateCallResult, type ProvisionNumberOptions as TelnyxProvisionNumberOptions, type ProvisionNumberResult as TelnyxProvisionNumberResult, TelnyxSTT, TelnyxSTTInputFormat, TelnyxSTTSampleRate, type Transcript as TelnyxSTTTranscript, TelnyxTTS, TelnyxTTSSampleRate, TelnyxTTSVoice, type TelnyxTranscriptionEngine, TestSession, TfidfLoopDetector, type TfidfLoopDetectorOptions, Tool, type ToolDefinition, type ToolExecutor, type ToolHandler, type ToolOptions, type TunnelHandle, type TurnMetrics, Carrier$2 as Twilio, TwilioAdapter, type TwilioAdapterOptions, type TwilioCarrierOptions, type ConfigureNumberOptions$1 as TwilioConfigureNumberOptions, type InitiateCallOptions$2 as TwilioInitiateCallOptions, type InitiateCallResult$2 as TwilioInitiateCallResult, type ProvisionNumberOptions$1 as TwilioProvisionNumberOptions, type ProvisionNumberResult$1 as TwilioProvisionNumberResult, ULTRAVOX_DEFAULT_API_BASE, ULTRAVOX_DEFAULT_SR, type UltravoxEventHandler, UltravoxRealtimeAdapter, type UserState, STT$5 as WhisperSTT, type WhisperSTTOptions, assemblyai, builtinClipPath, calculateRealtimeCost, calculateSttCost, calculateTelephonyCost, calculateTtsCost, callsToCsv, callsToJson, cartesia, createResampler16kTo8k, createResampler24kTo16k, createResampler24kTo8k, createResampler8kTo16k, deepgram, defineTool, elevenlabs, evaluateStrategies as evaluateBargeInStrategies, filterEmoji, filterForTTS, filterMarkdown, formatDtmf, geminiLive, getLogger, guardrail, initTracing, isRemoteUrl, isTracingEnabled, isWebSocketUrl, lmnt, makeAuthMiddleware, mergePricing, mixPcm, mountApi, mountDashboard, mulawToPcm16, notifyDashboard, openaiTts, openclawConsult, openclawPostCallNotifier, pcm16ToMulaw, resample16kTo8k, resample24kTo16k, resample8kTo16k, resamplePcm, resetStrategies as resetBargeInStrategies, rime, scheduleCron, scheduleInterval, scheduleOnce, selectSoundFromList, setLogger, soniox, speechmatics, startSpan, startTunnel, tool, ultravox, whisper };
+declare const hermes: Readonly<{
+    LLM: typeof LLM$1;
+}>;
+declare const openclaw: Readonly<{
+    LLM: typeof LLM;
+}>;
+declare const openaiCompatible: Readonly<{
+    LLM: typeof LLM$3;
+}>;
+declare const custom: Readonly<{
+    LLM: typeof LLM$2;
+}>;
+
+export { type AgentOptions, type AgentState, AllProvidersFailedError, type AnthropicConversion, LLM$7 as AnthropicLLM, type AnthropicLLMOptions, type AnthropicMessage, AssemblyAIEncoding, AssemblyAIModel, STT$1 as AssemblyAISTT, type AssemblyAISTTOptions, type AudioConfig, type AudioSource, AuthenticationError, type BackgroundAudioOptions, BackgroundAudioPlayer, type EvaluateContext as BargeInEvaluateContext, type BargeInStrategy, BuiltinAudioClip, type BuiltinAudioClipName, type BuiltinPcmSource, type CallControl, type CallEvent, type CallEventHandler, type CallMetrics, CallMetricsAccumulator, type CallOutcome, type CallRecord, type CallResult, type CarrierKind, type CartesiaEncoding, STT$3 as CartesiaSTT, type CartesiaSTTOptions, TTS$3 as CartesiaTTS, CartesiaTTSModel, type CartesiaTTSOptions, CartesiaTTSVoiceMode, LLM$5 as CerebrasLLM, type CerebrasLLMOptions, ChatContext, type ChatMessage, type ChatRole, CloudflareTunnel, type ConsultConfig, type ConversationStateSnapshot, type CostBreakdown, LLM$2 as CustomLLM, type CustomLLMOptions, DEFAULT_MIN_SENTENCE_LEN, DEFAULT_PRICING, DTMF_EVENTS, DeepFilterNetFilter, type DeepFilterNetOptions, DeepgramModel, STT$6 as DeepgramSTT, type DeepgramSTTOptions, DefaultToolExecutor, type DefaultToolExecutorOptions, type DefineToolInput, type DtmfEvent, ConvAI as ElevenLabsConvAI, ElevenLabsConvAIAdapter, type ConvAIOptions as ElevenLabsConvAIOptions, ElevenLabsModel, ElevenLabsOutputFormat, ElevenLabsTTS as ElevenLabsRestTTS, TTS$6 as ElevenLabsTTS, type ElevenLabsTTSOptions, type ElevenLabsWebSocketOptions, TTS$5 as ElevenLabsWebSocketTTS, type EouTrigger, ErrorCode, EventBus, FallbackLLMProvider, type FallbackLLMProviderOptions, type FilePcmSource, GEMINI_DEFAULT_INPUT_SR, GEMINI_DEFAULT_OUTPUT_SR, GeminiLiveAdapter, type GeminiLiveEventHandler, LLM$4 as GoogleLLM, type GoogleLLMOptions, LLM$6 as GroqLLM, type GroqLLMOptions, Guardrail$1 as Guardrail, type GuardrailOptions, LLM$1 as HermesLLM, type HermesLLMOptions, type HookContext, IVRActivity, type IVRActivityOptions, type IVRToolDefinition, type IncomingMessage, type InitTracingOptions, TTS as InworldTTS, type InworldTTSOptions, type JobCallback, KrispFrameDuration, KrispSampleRate, KrispVivaFilter, type KrispVivaFilterOptions, type LLMChunk, LLMLoop, type LLMProvider, LMNTAudioFormat, LMNTModel, LMNTSampleRate, TTS$1 as LMNTTTS, type LMNTTTSOptions, type LatencyBreakdown, type LocalCallOptions, type LocalConfig, type LocalOptions, type Logger, type LoopCallback, type MessageHandler, MetricsStore, MinWordsStrategy, type MinWordsStrategyOptions, type ModelPricing, Ngrok, type OpenAICompatibleConsult, LLM$3 as OpenAICompatibleLLM, type OpenAICompatibleLLMOptions, OpenAICompatibleLLMProvider, LLM$8 as OpenAILLM, type OpenAILLMOptions, OpenAILLMProvider, type OpenAIMessage, Realtime as OpenAIRealtime, Realtime2 as OpenAIRealtime2, OpenAIRealtime2Adapter, type Realtime2Options as OpenAIRealtime2Options, OpenAIRealtimeAdapter, OpenAIRealtimeAudioFormat, OpenAIRealtimeModel, type RealtimeOptions as OpenAIRealtimeOptions, OpenAIRealtimeVADType, TTS$4 as OpenAITTS, type OpenAITTSOptions, STT$4 as OpenAITranscribeSTT, type OpenAITranscribeSTTOptions, OpenAITranscriptionModel, OpenAIVoice, LLM as OpenClawLLM, type OpenClawLLMOptions, PRICING_LAST_UPDATED, PRICING_VERSION, type ParamSpec, PartialStreamError, Patter, PatterConfigError, PatterConnectionError, PatterError, type PatterEventType, PatterTool, type PatterToolExecuteArgs, type PatterToolOptions, type PatterToolResult, PcmCarry, PipelineHookExecutor, type PipelineHooks, type PipelineMessageHandler, Carrier as Plivo, PlivoAdapter, type PlivoCarrierOptions, type InitiateCallOptions as PlivoInitiateCallOptions, type InitiateCallResult as PlivoInitiateCallResult, PricingUnit, type PricingUnitValue, type ProviderPricing, ProvisionError, RateLimitError, type RawPcmSource, type RealtimeConfig, type RealtimeTurnDetection, RemoteMessageHandler, RimeAudioFormat, RimeModel, TTS$2 as RimeTTS, type RimeTTSOptions, SPAN_BARGEIN, SPAN_CALL, SPAN_ENDPOINT, SPAN_LLM, SPAN_STT, SPAN_TOOL, SPAN_TTS, type SSEEvent, type STTConfig, type ScheduleHandle, SentenceChunker, type ServeOptions, type SessionContext, type SilenceCallback, type SileroSampleRate, SileroVAD, type SileroVADOptions, STT$2 as SonioxSTT, type SonioxSTTOptions$1 as SonioxSTTOptions, type Span, type SpeechEventCallback, SpeechEvents, SpeechmaticsAudioEncoding, SpeechmaticsOperatingPoint, STT as SpeechmaticsSTT, type SpeechmaticsSTTOptions, SpeechmaticsSampleRate, SpeechmaticsServerMessage, TurnDetectionMode as SpeechmaticsTurnDetectionMode, StatefulResampler, type StatefulResamplerOptions, Static as StaticTunnel, type TTSConfig, Carrier$1 as Telnyx, TelnyxAdapter, type TelnyxCarrierOptions, type ConfigureNumberOptions as TelnyxConfigureNumberOptions, type EndCallOptions as TelnyxEndCallOptions, type InitiateCallOptions$1 as TelnyxInitiateCallOptions, type InitiateCallResult$1 as TelnyxInitiateCallResult, type ProvisionNumberOptions as TelnyxProvisionNumberOptions, type ProvisionNumberResult as TelnyxProvisionNumberResult, TelnyxSTT, TelnyxSTTInputFormat, TelnyxSTTSampleRate, type Transcript as TelnyxSTTTranscript, TelnyxTTS, TelnyxTTSSampleRate, TelnyxTTSVoice, type TelnyxTranscriptionEngine, TestSession, TfidfLoopDetector, type TfidfLoopDetectorOptions, Tool, type ToolDefinition, type ToolExecutor, type ToolHandler, type ToolOptions, type TunnelHandle, type TurnMetrics, Carrier$2 as Twilio, TwilioAdapter, type TwilioAdapterOptions, type TwilioCarrierOptions, type ConfigureNumberOptions$1 as TwilioConfigureNumberOptions, type InitiateCallOptions$2 as TwilioInitiateCallOptions, type InitiateCallResult$2 as TwilioInitiateCallResult, type ProvisionNumberOptions$1 as TwilioProvisionNumberOptions, type ProvisionNumberResult$1 as TwilioProvisionNumberResult, ULTRAVOX_DEFAULT_API_BASE, ULTRAVOX_DEFAULT_SR, type UltravoxEventHandler, UltravoxRealtimeAdapter, type UserState, STT$5 as WhisperSTT, type WhisperSTTOptions, assemblyai, builtinClipPath, calculateRealtimeCost, calculateSttCost, calculateTelephonyCost, calculateTtsCost, callsToCsv, callsToJson, cartesia, createResampler16kTo8k, createResampler24kTo16k, createResampler24kTo8k, createResampler8kTo16k, custom, deepgram, defineTool, elevenlabs, evaluateStrategies as evaluateBargeInStrategies, filterEmoji, filterForTTS, filterMarkdown, formatDtmf, geminiLive, getLogger, guardrail, hashCaller, hermes, initTracing, isRemoteUrl, isTracingEnabled, isWebSocketUrl, lmnt, makeAuthMiddleware, mergePricing, mixPcm, mountApi, mountDashboard, mulawToPcm16, notifyDashboard, openaiCompatible, openaiTts, openclaw, openclawConsult, openclawPostCallNotifier, pcm16ToMulaw, resample16kTo8k, resample24kTo16k, resample8kTo16k, resamplePcm, resetStrategies as resetBargeInStrategies, rime, scheduleCron, scheduleInterval, scheduleOnce, selectSoundFromList, setLogger, soniox, speechmatics, startSpan, startTunnel, tool, ultravox, whisper };