@pyai/sdk 0.2.2 → 0.3.1

package/src/index.ts

@@ -34,6 +34,9 @@ export class PyAIError extends Error {
 }
 
 export interface Voice {
+  /** Canonical catalog identifier returned by GET /v1/voices. */
+  voice_id: string;
+  /** SDK compatibility alias, always equal to voice_id. */
   id: string;
   name?: string;
   gender?: string;
@@ -41,6 +44,11 @@ export interface Voice {
   [k: string]: unknown;
 }
 
+function normalizeVoice(value: Record<string, unknown>): Voice {
+  const voiceId = String(value.voice_id ?? value.id ?? "");
+  return { ...value, voice_id: voiceId, id: voiceId } as Voice;
+}
+
 export interface ListResponse<T> {
   object: "list";
   data: T[];
@@ -62,13 +70,13 @@ export interface TranscriptionJob {
  * Output container/codec for `audio.speech`. This is the **exact** set the
  * server accepts on `POST /v1/audio/speech`, any other value is rejected with
  * `400 unsupported_format`. The default (when `response_format` is omitted) is
- * `mp3`. Omit `sample_rate` for the engine's native 24 kHz (`g711_*` is always
+ * `wav`. Omit `sample_rate` for the engine's native 24 kHz (`g711_*` is always
  * 8 kHz).
  *
  * | format | rates (Hz) | Content-Type |
  * |---|---|---|
- * | `mp3` (default) | 8000/16000/24000/48000 | `audio/mpeg` |
- * | `wav` | 8000/16000/24000/48000 | `audio/wav` |
+ * | `wav` (default) | 8000/16000/24000/48000 | `audio/wav` |
+ * | `mp3` | 8000/16000/24000/48000 | `audio/mpeg` |
  * | `opus` | 8000/16000/24000/48000 | `audio/ogg` |
  * | `aac` | 8000/16000/24000/48000 | `audio/aac` |
  * | `flac` | 8000/16000/24000/48000 | `audio/flac` |
@@ -89,14 +97,17 @@ export const SPEECH_FORMATS = ["wav", "mp3", "opus", "aac", "flac", "pcm", "g711
 export const SPEECH_SAMPLE_RATES = [8000, 16000, 24000, 48000] as const;
 export type SpeechSampleRate = (typeof SPEECH_SAMPLE_RATES)[number];
 
+/** Canonical Speak model plus the intentional OpenAI drop-in aliases. */
+export type SpeakModel = "pyai-speak" | "tts-1" | "tts-1-hd";
+
 export interface SpeechParams {
   input: string;
   voice?: string;
-  model?: string;
+  model?: SpeakModel;
   /**
    * Output container/codec, resampled+encoded server-side. One of
    * {@link SpeechFormat}, anything else is a `400 unsupported_format`. Omit for
-   * the default of `mp3`.
+   * the default of `wav`.
    *
    * `g711_ulaw`/`g711_alaw` return raw 8 kHz mono G.711, the bytes Twilio/SIP
    * media streams expect, so you can hand the response straight to a telephony
@@ -113,19 +124,26 @@ export interface SpeechParams {
    * telephony pipelines, most often with `response_format: "pcm"`.
    */
   sample_rate?: SpeechSampleRate;
+  /** Reserved; currently returns `400 unsupported_parameter` when provided. */
   speed?: number;
   /**
-   * Deterministic sampling seed for reproducible eval runs. Forward-compatible:
-   * honored once the engine supports it (otherwise ignored server-side), so it's
-   * always safe to send.
+   * Reserved; currently returns `400 unsupported_parameter` when provided.
    */
   seed?: number;
   /**
-   * Sampling temperature (lower = more deterministic). Forward-compatible, * honored once the engine supports it, otherwise ignored.
+   * Reserved; currently returns `400 unsupported_parameter` when provided.
    */
   temperature?: number;
 }
 
+function assertActiveSpeechParams(params: SpeechParams): void {
+  for (const field of ["speed", "seed", "temperature"] as const) {
+    if (params[field] !== undefined) {
+      throw new Error(`${field} is reserved but not active on Speak`);
+    }
+  }
+}
+
 export interface CreateJobParams {
   audio_url: string;
   model?: string;
@@ -137,8 +155,6 @@ export interface CreateJobParams {
 }
 
 export interface RealtimeOptions {
-  /** "omni" (agentic voice) or "flow" (legacy voice duplex). Default "omni". */
-  product?: "omni" | "flow";
   /**
    * Optional opaque tag echoed to your `kb_endpoint` and recorded on the call.
    * Omni is zero-state: the session is authorized by the key's org, so there is
@@ -146,12 +162,10 @@ export interface RealtimeOptions {
    */
   sessionLabel?: string;
   /**
-   * @deprecated Use {@link sessionLabel}. Kept for back-compat, emitted as the
-   * `agent_id` query alias, which the gateway still accepts. Ignored if
-   * `sessionLabel` is set.
+   * Extra canonical query params (`format`, `rate`, or the intentional
+   * server-side `api_key` auth option). Retired connect aliases and model/token
+   * selectors are rejected.
    */
-  agentId?: string;
-  /** Extra query params (e.g. format, rate). */
   query?: Record<string, string>;
 }
 
@@ -195,6 +209,8 @@ export interface OmniSession {
 
 /** Frame `type`s emitted by the Hear streaming-STT WebSocket. */
 export const HearFrameType = {
+  /** Applied endpointing configuration and validation warnings. */
+  ConfigAck: "config_ack",
   /** Eager live hypothesis for the current utterance. */
   Partial: "partial",
   /** Partial whose prefix has stabilized (won't be revised). */
@@ -232,7 +248,7 @@ export const ErrorCode = {
   Unauthorized: "unauthorized",
   Forbidden: "forbidden",
   OriginNotAllowed: "origin_not_allowed",
-  InvalidAgentId: "invalid_agent_id",
+  InvalidSessionLabel: "invalid_session_label",
   CreditExhausted: "credit_exhausted",
   KeyBudgetExceeded: "key_budget_exceeded",
   InsufficientQuota: "insufficient_quota",
@@ -255,6 +271,24 @@ export interface HearGroundingPassage {
   score: number;
 }
 
+/** One endpointing validation result echoed in a `config_ack` frame. */
+export interface HearConfigWarning {
+  field: string;
+  value: unknown;
+  effective?: number;
+  reason: "clamped_to_range" | "not_a_number" | "unknown_config_field" | (string & {});
+}
+
+/** Applied endpointing settings after connect-time or mid-session config. */
+export interface HearConfigAckFrame {
+  type: "config_ack";
+  endpointing_ms: number;
+  effective_floor_ms: number;
+  effective_ceiling_ms: number;
+  score_interval_ms: number;
+  warnings: HearConfigWarning[];
+}
+
 /** Live hypothesis frame (`partial` / `partial_stable`). */
 export interface HearPartialFrame {
   type: "partial" | "partial_stable";
@@ -269,6 +303,12 @@ export interface HearPartialFrame {
 }
 
 /** Finalized-utterance frame (`speech_final` / `final`). */
+export type HearEndpointReason =
+  | "peak_te_early"
+  | "silence_backstop"
+  | "commit"
+  | (string & {});
+
 export interface HearFinalFrame {
   type: "speech_final" | "final";
   text: string;
@@ -276,6 +316,8 @@ export interface HearFinalFrame {
   t_ms: number;
   /** Active-speech length of the utterance (the billed signal), ms. */
   audio_ms: number;
+  /** Why the utterance ended. Log this when tuning automatic endpointing. */
+  endpoint_reason: HearEndpointReason;
   /** Present only with Cue grounding enabled (top KB passages). */
   grounding?: HearGroundingPassage[];
 }
@@ -288,7 +330,7 @@ export interface HearUsageFrame {
   type: "usage";
   /** `hear` for plain streaming, `cue` when grounding was enabled. */
   product: "hear" | "cue";
-  /** The billed meter (`hear.requests` or `cue.minutes`). */
+  /** The billed meter (`hear.minutes` or `cue.minutes`). */
   meter: string;
   /** Summed active-speech audio billed for the session, in seconds. */
   audio_seconds: number;
@@ -303,7 +345,12 @@ export interface HearErrorFrame {
   message: string;
 }
 
-export type HearFrame = HearPartialFrame | HearFinalFrame | HearUsageFrame | HearErrorFrame;
+export type HearFrame =
+  | HearConfigAckFrame
+  | HearPartialFrame
+  | HearFinalFrame
+  | HearUsageFrame
+  | HearErrorFrame;
 
 /**
  * Minimal structural WebSocket, matches both the browser/Node global
@@ -324,8 +371,12 @@ export type WebSocketCtor = new (url: string, protocols?: string | string[]) =>
 export interface HearStreamOptions {
   /** Streaming STT model. Server default `pyai-hear`. */
   model?: string;
-  /** ISO-639-1 hint, e.g. "en". */
-  language?: string;
+  /**
+   * Hear is English-only. Set `"en"` explicitly; omission also means English
+   * and does not enable language detection. Other values receive
+   * `400 unsupported_language`.
+   */
+  language?: "en";
   /** Input PCM sample rate in Hz. Default 16000 server-side. */
   sampleRate?: number;
   /** Audio frame encoding. Default "pcm16". */
@@ -339,16 +390,14 @@ export interface HearStreamOptions {
    */
   numerals?: boolean;
   /**
-   * Turn-segmentation tuning: trailing-pause (ms, 50-2000) that ends an
-   * utterance. Forwards `?endpointing_ms=`, clamped + honored once the engine
-   * supports it; a no-op when omitted. Drive end-of-turn yourself with
-   * {@link HearStream.commit} for full control today.
+   * Minimum trailing-pause length before an utterance may end (50-5000 ms).
+   * Turn detection may wait longer, bounded at `max(endpointingMs, 1500)`.
+   * The server confirms the applied value through `onConfigAck`.
    */
   endpointingMs?: number;
   /**
-   * Enable Cue knowledge-base grounding: sends `{type:"config",grounding:true}`
-   * on open, after which `speech_final`/`final` frames carry a `grounding`
-   * array. Bills a single `cue.minutes` line instead of the Hear rate.
+   * Reserved Cue grounding configuration. Grounding is not active on the
+   * serving Hear stream; do not rely on grounding frames or Cue metering yet.
    */
   grounding?: boolean;
   /** Cue: number of KB passages to retrieve per turn (1-20, default 3). */
@@ -360,8 +409,11 @@ export interface HearStreamOptions {
   groundingTimeoutMs?: number;
   /** Extra query params merged onto the connect URL. */
   query?: Record<string, string>;
-  /** Fired once the socket opens (after the optional grounding config). */
+  /** Fired once the socket opens. */
   onOpen?: () => void;
+  /** Fired after connect-time or mid-session endpointing config. Assert that
+   * `warnings` is empty before relying on the requested floor. */
+  onConfigAck?: (frame: HearConfigAckFrame) => void;
   /** Fired on `partial` / `partial_stable`. */
   onPartial?: (frame: HearPartialFrame) => void;
   /** Fired on `speech_final` / `final`. */
@@ -379,8 +431,10 @@ export interface HearStreamOptions {
 /**
  * A live Hear streaming-STT session. Hides the frame protocol: stream audio
  * with {@link HearStream.sendAudio}, get `onPartial`/`onFinal`/`onError`
- * callbacks, force-finalize with {@link HearStream.commit}, and flush+close
- * with {@link HearStream.close}. Construct via `pyai.audio.transcriptions.stream()`.
+ * callbacks, update the silence floor with
+ * {@link HearStream.configureEndpointing}, force-finalize with
+ * {@link HearStream.commit}, and flush+close with {@link HearStream.close}.
+ * Construct via `pyai.audio.transcriptions.stream()`.
  */
 export class HearStream {
   private readonly ws: WebSocketLike;
@@ -389,6 +443,11 @@ export class HearStream {
 
   constructor(url: string, subprotocol: string, opts: HearStreamOptions) {
     this.opts = opts;
+    if (opts.grounding) {
+      throw new Error(
+        "Cue grounding is not active on the serving Hear stream; omit grounding until the API reference marks it active",
+      );
+    }
     const WS = opts.webSocket ?? (globalThis as { WebSocket?: WebSocketCtor }).WebSocket;
     if (!WS) {
       throw new Error(
@@ -397,17 +456,6 @@ export class HearStream {
     }
     this.ws = new WS(url, [subprotocol]);
     this.ws.onopen = () => {
-      if (opts.grounding) {
-        try {
-          const cfg: Record<string, unknown> = { type: "config", grounding: true };
-          if (opts.groundingK != null) cfg.grounding_k = opts.groundingK;
-          if (opts.groundingMinScore != null) cfg.grounding_min_score = opts.groundingMinScore;
-          if (opts.groundingTimeoutMs != null) cfg.grounding_timeout_ms = opts.groundingTimeoutMs;
-          this.ws.send(JSON.stringify(cfg));
-        } catch {
-          /* surfaced via onerror */
-        }
-      }
       opts.onOpen?.();
     };
     this.ws.onmessage = (ev) => this.handleMessage(ev.data);
@@ -429,6 +477,9 @@ export class HearStream {
       return;
     }
     switch (frame.type) {
+      case HearFrameType.ConfigAck:
+        this.opts.onConfigAck?.(frame);
+        break;
       case HearFrameType.Partial:
       case HearFrameType.PartialStable:
         this.opts.onPartial?.(frame);
@@ -454,6 +505,11 @@ export class HearStream {
     this.ws.send(chunk);
   }
 
+  /** Change the minimum trailing-pause floor without reconnecting. */
+  configureEndpointing(endpointingMs: number): void {
+    this.ws.send(JSON.stringify({ type: "config", endpointing_ms: endpointingMs }));
+  }
+
   /** Force-finalize the current utterance (e.g. on VAD end-of-turn). */
   commit(): void {
     this.ws.send(JSON.stringify({ type: "commit" }));
@@ -586,6 +642,88 @@ export interface OmniServerFrame {
   [k: string]: unknown;
 }
 
+/** Canonical, sanitized transcript delivered by the native Omni demux.
+ * The live wire sends caller text deltas; the JSON fields are SDK-owned
+ * normalization so applications don't have to special-case the byte payload. */
+export interface OmniTranscriptFrame extends OmniServerFrame {
+  event: "transcript";
+  role: "user" | "assistant";
+  text: string;
+  final: boolean;
+  /** Live text frames append; legacy JSON frames replace unless they use `delta`. */
+  mode: "delta" | "replace";
+  /** Optional ordering hint on legacy JSON frames. */
+  sequence?: number;
+}
+
+const OMNI_TRANSCRIPT_MAX_BYTES = 16_384;
+const OMNI_TRANSCRIPT_MAX_CHARS = 4_000;
+
+function omniTranscriptText(value: unknown): string | null {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= OMNI_TRANSCRIPT_MAX_CHARS
+    && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)
+    ? value
+    : null;
+}
+
+function omniTranscriptRole(value: unknown): "user" | "assistant" | null {
+  if (value === "user" || value === "caller" || value === "human") return "user";
+  if (value === "assistant" || value === "agent") return "assistant";
+  return null;
+}
+
+/** Normalize the live UTF-8 `0x02` text body and bounded legacy JSON bodies. */
+export function normalizeOmniTranscriptBody(bytes: Uint8Array): OmniTranscriptFrame | null {
+  if (bytes.byteLength === 0 || bytes.byteLength > OMNI_TRANSCRIPT_MAX_BYTES) return null;
+  let decoded: string;
+  try {
+    decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+  // The serving engine's canonical payload is plain UTF-8 caller text, not
+  // JSON. Each frame is a delta for the current caller turn.
+  if (!decoded.trimStart().startsWith("{")) {
+    const text = omniTranscriptText(decoded);
+    return text
+      ? { event: "transcript", role: "user", text, final: false, mode: "delta" }
+      : null;
+  }
+
+  // Keep accepting a bounded direct object for older bridges and recordings.
+  let value: unknown;
+  try {
+    value = JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const payload = value as Record<string, unknown>;
+  if (payload.type !== undefined
+    || (payload.event !== undefined && payload.event !== "transcript")) return null;
+  const role = omniTranscriptRole(payload.role ?? payload.speaker);
+  const mode = typeof payload.delta === "string" ? "delta" : "replace";
+  const text = omniTranscriptText(
+    mode === "delta" ? payload.delta : typeof payload.text === "string" ? payload.text : payload.transcript,
+  );
+  if (!role || !text) return null;
+  if (payload.final !== undefined && typeof payload.final !== "boolean") return null;
+  if (payload.sequence !== undefined
+    && (typeof payload.sequence !== "number"
+      || !Number.isSafeInteger(payload.sequence)
+      || payload.sequence < 0)) return null;
+  return {
+    event: "transcript",
+    role,
+    text,
+    final: payload.final === true,
+    mode,
+    ...(payload.sequence === undefined ? {} : { sequence: payload.sequence as number }),
+  };
+}
+
 /** A binary agent-audio chunk delivered to {@link OmniConnectOptions.onAudio}. */
 export type OmniAudioChunk = ArrayBuffer | ArrayBufferView | Blob;
 
@@ -629,7 +767,7 @@ export interface OmniToolDef {
 }
 
 export interface OmniToolCallFrame {
-  type: "tool_call";
+  event: "tool_call";
   call_id: string;
   name: string;
   arguments?: Record<string, unknown>;
@@ -655,7 +793,7 @@ export interface OmniConfigure {
   /**
    * Session language, end to end (recognition, reasoning, voice). Also
    * settable on the agent profile (`language` on `POST /v1/agents`), which
-   * applies automatically when connecting with `session_label={agent_id}`;
+   * applies automatically when `session_label` is the saved profile id;
    * an inline value here wins for the session. Default `en`. Fail-safe: an
    * unknown/not-yet-enabled language falls back to `en` (the `configured`
    * ack carries `language_active` + `language_fallback: true`), the call
@@ -678,7 +816,11 @@ export interface OmniConnectOptions {
    * so a page never holds a secret key.
    */
   token?: string;
-  /** Connect-URL sample rate: 24000 browser, 16000 wideband telephony, 8000 G.711/Twilio. */
+  /**
+   * Caller-input sample rate. `24000` and `16000` sessions receive agent audio
+   * at 24 kHz; `8000` sessions receive 8 kHz. Read `hello.audio_out` rather than
+   * assuming output matches this value.
+   */
   rate?: 24000 | 16000 | 8000;
   /** Connect-URL audio format. Default `pcm16`. */
   format?: "pcm16";
@@ -701,7 +843,7 @@ export interface OmniConnectOptions {
   onSessionStarted?: (frame: OmniServerFrame) => void;
   /** Fired on `turn` boundaries. */
   onTurn?: (frame: OmniServerFrame) => void;
-  /** Fired on `transcript` text frames. */
+  /** Fired for each normalized caller-transcript delta (`0x02` plain UTF-8 live). */
   onTranscript?: (frame: OmniServerFrame) => void;
   /** Fired on `barge_in` / `flush` (user interrupted). */
   onBargeIn?: (frame: OmniServerFrame) => void;
@@ -741,6 +883,8 @@ export class OmniConnection {
   private closed = false;
   /** Serializes async Blob reads in {@link sendAudio} so frames stay ordered. */
   private blobTail: Promise<void> = Promise.resolve();
+  /** Serializes inbound Blob decoding so browser frames stay ordered. */
+  private inboundTail: Promise<void> = Promise.resolve();
 
   constructor(url: string, subprotocol: string, opts: OmniConnectOptions) {
     this.opts = opts;
@@ -761,7 +905,16 @@ export class OmniConnection {
       }
       opts.onOpen?.();
     };
-    this.ws.onmessage = (ev) => this.handleMessage(ev.data);
+    this.ws.onmessage = (ev) => {
+      const reportDecodeError = (error: unknown) => {
+        opts.onError?.(error instanceof Error ? error : new Error("Could not decode Omni frame"));
+      };
+      if (typeof Blob !== "undefined" && ev.data instanceof Blob) {
+        this.inboundTail = this.inboundTail.then(() => this.handleMessage(ev.data)).catch(reportDecodeError);
+      } else {
+        void this.handleMessage(ev.data).catch(reportDecodeError);
+      }
+    };
     this.ws.onerror = (ev) => opts.onError?.(ev instanceof Error ? ev : new Error("WebSocket error"));
     this.ws.onclose = (ev) => {
       this.closed = true;
@@ -769,15 +922,17 @@ export class OmniConnection {
     };
   }
 
-  private handleMessage(data: unknown): void {
+  private async handleMessage(data: unknown): Promise<void> {
     // Server → client binary frames are TYPE-TAGGED by their first byte:
-    // 0x01 = agent audio (PCM16) · 0x02 = transcript JSON · 0x03 = control JSON.
+    // 0x01 = agent audio (PCM16) · 0x02 = transcript UTF-8 · 0x03 = control JSON.
     // (Treating every binary frame as audio, the old behavior, plays the
     // 0x03/0x02 frames as a glitch and drops every event/transcript.)
     if (typeof data !== "string") {
-      const bytes = omniToBytes(data);
+      const bytes = typeof Blob !== "undefined" && data instanceof Blob
+        ? new Uint8Array(await data.arrayBuffer())
+        : omniToBytes(data);
       if (!bytes) {
-        this.opts.onAudio?.(data as OmniAudioChunk); // Blob/unknown, best-effort
+        this.opts.onError?.(new Error("Unsupported Omni binary frame"));
         return;
       }
       const tag = bytes[0];
@@ -785,36 +940,39 @@ export class OmniConnection {
         this.opts.onAudio?.(bytes.slice(1) as OmniAudioChunk); // copy → aligned PCM16
         return;
       }
-      if (tag === 0x02 || tag === 0x03) {
+      if (tag === 0x02) {
+        const transcript = normalizeOmniTranscriptBody(bytes.subarray(1));
+        if (transcript) this.dispatchFrame(transcript);
+        else this.opts.onError?.(new Error("Unparseable Omni transcript frame"));
+        return;
+      }
+      if (tag === 0x03) {
         try {
-          const parsed = JSON.parse(new TextDecoder().decode(bytes.subarray(1))) as OmniServerFrame;
-          // The 0x02 tag is authoritative for transcript even if the JSON omits `event`.
-          this.dispatchFrame(tag === 0x02 ? { ...parsed, event: "transcript" } : parsed);
+          const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(1))) as OmniServerFrame;
+          if (parsed?.event === OmniEvent.Transcript) {
+            this.opts.onError?.(new Error("Omni transcript events must use a binary 0x02 frame"));
+            return;
+          }
+          this.dispatchFrame(parsed);
         } catch {
           this.opts.onError?.(new Error("Unparseable Omni binary frame"));
         }
         return;
       }
-      this.opts.onAudio?.(data as OmniAudioChunk); // untagged, forward-compat as audio
+      const tagName = tag === undefined ? "empty" : `0x${tag.toString(16).padStart(2, "0")}`;
+      this.opts.onError?.(new Error(`Ignored unknown Omni binary frame tag ${tagName}`));
       return;
     }
-    // Text frame (e.g. a server-side broker relay).
-    try {
-      this.dispatchFrame(JSON.parse(data) as OmniServerFrame);
-    } catch {
-      this.opts.onError?.(new Error(`Unparseable Omni frame: ${data.slice(0, 120)}`));
-    }
+    this.opts.onError?.(new Error("Unexpected Omni text frame; server frames must use binary 0x01/0x02/0x03 tags"));
   }
 
   private dispatchFrame(frame: OmniServerFrame): void {
-    const raw = frame as unknown as { event?: unknown; type?: unknown };
-    const eventName =
-      typeof raw.event === "string"
-        ? raw.event
-        : typeof raw.type === "string"
-          ? raw.type
-          : "";
-    this.opts.onEvent?.({ ...frame, event: eventName });
+    const eventName = (frame as { event?: unknown }).event;
+    if (typeof eventName !== "string" || !eventName) {
+      this.opts.onError?.(new Error("Omni server control frame is missing its event key"));
+      return;
+    }
+    this.opts.onEvent?.(frame);
     switch (eventName) {
       case OmniEvent.Hello:
         this.opts.onHello?.(frame);
@@ -856,7 +1014,10 @@ export class OmniConnection {
    * `{"event":"configure"}` is acked but silently dropped by the engine.)
    */
   configure(cfg: OmniConfigure): void {
-    this.ws.send(omniControlFrame({ type: "configure", ...cfg }));
+    const payload: Record<string, unknown> = { ...cfg };
+    delete payload.type;
+    delete payload.event;
+    this.ws.send(omniControlFrame({ type: "configure", ...payload }));
   }
 
   /**
@@ -896,7 +1057,12 @@ export class OmniConnection {
    * never `event`.
    */
   send(frame: Record<string, unknown>): void {
-    this.ws.send(omniControlFrame(frame));
+    if (typeof frame.type !== "string" || !frame.type) {
+      throw new TypeError("Omni client control frames must have a non-empty type key");
+    }
+    const payload = { ...frame };
+    delete payload.event;
+    this.ws.send(omniControlFrame(payload));
   }
 
   /** Close the session. */
@@ -1210,19 +1376,23 @@ export interface RecapCallTriggerInput {
 
 // --- AMD (answering-machine detection) -----------------------------------
 
-/** PyAI's richer answered-by vocabulary (superset of Twilio's enum). */
+/**
+ * The answered-by vocabulary on stored call records and the
+ * `amd.call.completed` webhook: the routing classes plus the machine subtypes.
+ */
 export type AmdAnsweredBy =
   | "human"
+  | "machine"
   | "voicemail"
-  | "live_voicemail"
   | "screening" // iPhone / Google Call Screen
   | "ivr"
-  | "human_gatekeeper"
+  | "music" // hold music
   | "sit_invalid" // dead / disconnected number
-  | "fax"
-  | "silence"
   | "unknown";
 
+/** The routing classes pushed on the mid-call wire event (`event: "amd"`). */
+export type AmdWireAnsweredBy = "human" | "machine" | "sit_invalid" | "unknown";
+
 /** Twilio's `AnsweredBy` enum, echoed for drop-in migration parity. */
 export type AmdTwilioAnsweredBy =
   | "human"
@@ -1272,11 +1442,16 @@ export interface AmdCall extends AmdCallSummary {
   error?: string | null;
 }
 
-/** A mid-call AMD decision event pushed on the stream (and to the webhook). */
+/**
+ * A mid-call AMD decision event pushed on the stream (and to the per-call
+ * TwiML `webhook`). Carries the coarse routing class; the machine subtype
+ * (`voicemail`/`ivr`/`screening`/`music`) is on the stored call record
+ * (`AmdCall`) and the `amd.call.completed` webhook instead.
+ */
 export interface AmdDecisionEvent {
   event?: "amd";
   call_id?: string;
-  answered_by?: AmdAnsweredBy;
+  answered_by?: AmdWireAnsweredBy;
   answered_by_twilio?: string | null;
   confidence?: number | null;
   decision_ms?: number | null;
@@ -1399,14 +1574,22 @@ export class PyAI {
   // --- voices -------------------------------------------------------------
 
   voices = {
-    list: (params: { gender?: string; region?: string } = {}): Promise<ListResponse<Voice>> => {
+    list: async (params: { gender?: string; region?: string } = {}): Promise<ListResponse<Voice>> => {
       const q = new URLSearchParams();
       if (params.gender) q.set("gender", params.gender);
       if (params.region) q.set("region", params.region);
       const qs = q.toString();
-      return this.getJson(`/v1/voices${qs ? `?${qs}` : ""}`);
+      const page = await this.getJson<ListResponse<Record<string, unknown>>>(
+        `/v1/voices${qs ? `?${qs}` : ""}`,
+      );
+      return { ...page, data: page.data.map(normalizeVoice) };
     },
-    get: (id: string): Promise<Voice> => this.getJson(`/v1/voices/${encodeURIComponent(id)}`),
+    get: async (id: string): Promise<Voice> =>
+      normalizeVoice(
+        await this.getJson<Record<string, unknown>>(
+          `/v1/voices/${encodeURIComponent(id)}`,
+        ),
+      ),
   };
 
   // --- audio --------------------------------------------------------------
@@ -1414,10 +1597,11 @@ export class PyAI {
   audio = {
     /** Text-to-speech. Returns the raw audio bytes (default WAV). */
     speech: async (params: SpeechParams): Promise<ArrayBuffer> => {
+      assertActiveSpeechParams(params);
       const res = await this.request("/v1/audio/speech", {
         method: "POST",
         headers: this.authHeaders({ "Content-Type": "application/json" }),
-        body: JSON.stringify({ model: "pyai-voice", ...params }),
+        body: JSON.stringify({ model: "pyai-speak", ...params }),
       });
       return res.arrayBuffer();
     },
@@ -1430,10 +1614,11 @@ export class PyAI {
      * iterable of Uint8Array chunks.
      */
     speechStream: async (params: SpeechParams): Promise<ReadableStream<Uint8Array>> => {
+      assertActiveSpeechParams(params);
       const res = await this.request("/v1/audio/speech", {
         method: "POST",
         headers: this.authHeaders({ "Content-Type": "application/json" }),
-        body: JSON.stringify({ model: "pyai-voice", ...params, stream: true }),
+        body: JSON.stringify({ model: "pyai-speak", ...params, stream: true }),
       });
       if (!res.body) throw new PyAIError(res.status, "Response had no body to stream");
       return res.body as ReadableStream<Uint8Array>;
@@ -1444,7 +1629,11 @@ export class PyAI {
         file: Blob;
         filename?: string;
         model?: string;
-        language?: string;
+        /**
+         * Hear is English-only. Omission means English, not auto-detect; other
+         * values receive `400 unsupported_language`.
+         */
+        language?: "en";
         response_format?: "json" | "text" | "verbose_json";
         /**
          * Deterministic seed for reproducible eval runs. Forward-compatible:
@@ -1516,7 +1705,7 @@ export class PyAI {
   clones = {
     /** List the org's cloned voices. */
     list: (): Promise<ListResponse<Voice>> => this.getJson("/v1/voice/clones"),
-    /** Enroll a custom voice from reference audio (>= ~10s). Scope `voice:clone`. */
+    /** Enroll a custom voice from reference audio (>= ~10s). Scope `speak:clone`. */
     create: async (params: { name: string; file: Blob; filename?: string }): Promise<Voice> => {
       const form = new FormData();
       form.set("name", params.name);
@@ -1535,7 +1724,7 @@ export class PyAI {
       if (!match) throw new PyAIError(404, `No cloned voice ${id}`, ErrorCode.NotFound);
       return match;
     },
-    /** Delete a cloned voice (tenant-isolated). Scope `voice:clone`. */
+    /** Delete a cloned voice (tenant-isolated). Scope `speak:clone`. */
     delete: async (id: string): Promise<void> => {
       await this.deleteReq(`/v1/voice/clones/${encodeURIComponent(id)}`);
     },
@@ -1756,7 +1945,7 @@ export class PyAI {
       const query: Record<string, string> = { ...(opts.query ?? {}) };
       if (opts.format) query.format = opts.format;
       if (opts.rate) query.rate = String(opts.rate);
-      const url = this.realtimeURL({ product: "omni", sessionLabel: opts.sessionLabel, query });
+      const url = this.realtimeURL({ sessionLabel: opts.sessionLabel, query });
       const sub = opts.token ? `pyai-key.${opts.token}` : this.realtimeSubprotocol();
       return new OmniConnection(url, sub, opts);
     },
@@ -1764,24 +1953,24 @@ export class PyAI {
 
   // --- realtime (WebSocket) ----------------------------------------------
 
-  /** Build the realtime WebSocket URL for the chosen product. */
+  /** Build the canonical Omni WebSocket URL. */
   realtimeURL(opts: RealtimeOptions = {}): string {
     const wsBase = this.baseURL.replace(/^http/, "ws");
     const q = new URLSearchParams(opts.query ?? {});
-    if ((opts.product ?? "omni") === "omni") {
-      // Omni's native realtime surface is /v1/omni. The session is authorized by
-      // the key's org (zero-state), sessionLabel is an optional opaque tag.
-      // format/rate are load-bearing on the connect URL, so default to
-      // browser-grade PCM16/24kHz.
-      if (opts.sessionLabel) q.set("session_label", opts.sessionLabel);
-      else if (opts.agentId) q.set("agent_id", opts.agentId); // deprecated alias
-      if (!q.has("format")) q.set("format", "pcm16");
-      if (!q.has("rate")) q.set("rate", "24000");
-      const qs = q.toString();
-      return `${wsBase}/v1/omni${qs ? `?${qs}` : ""}`;
+    // format/rate are load-bearing on the connect URL, so default to
+    // browser-grade PCM16/24kHz.
+    for (const key of ["agent", "agent_id", "agentId", "model", "access_token"]) {
+      if (q.has(key)) {
+        throw new Error(
+          `Omni query parameter "${key}" is not supported; use sessionLabel, format/rate, or api_key`,
+        );
+      }
     }
-    q.set("model", "pyai-flow-realtime");
-    return `${wsBase}/v1/realtime?${q.toString()}`;
+    if (opts.sessionLabel) q.set("session_label", opts.sessionLabel);
+    if (!q.has("format")) q.set("format", "pcm16");
+    if (!q.has("rate")) q.set("rate", "24000");
+    const qs = q.toString();
+    return `${wsBase}/v1/omni${qs ? `?${qs}` : ""}`;
   }
 
   /** The subprotocol that carries the key on a WS upgrade (browser-safe auth). */
@@ -1793,6 +1982,7 @@ export class PyAI {
   hearStreamURL(opts: HearStreamOptions = {}): string {
     const wsBase = this.baseURL.replace(/^http/, "ws");
     const q = new URLSearchParams(opts.query ?? {});
+    q.set("protocol", "pyai-hear-v1");
     if (opts.model) q.set("model", opts.model);
     if (opts.language) q.set("language", opts.language);
     if (opts.sampleRate !== undefined) q.set("sample_rate", String(opts.sampleRate));