@shogo-ai/voice 1.9.13 → 2.4.1

package/dist/index.cjs

@@ -28,6 +28,10 @@ __export(index_exports, {
   DEFAULT_ELEVENLABS_BASE_URL: () => DEFAULT_ELEVENLABS_BASE_URL,
   DEFAULT_MEMORY_BLOCK: () => DEFAULT_MEMORY_BLOCK,
   DEFAULT_MUSIC_MODEL: () => DEFAULT_MUSIC_MODEL,
+  DEFAULT_SOUND_GENERATION_MODEL: () => DEFAULT_SOUND_GENERATION_MODEL,
+  DEFAULT_SPEECH_TO_TEXT_MODEL: () => DEFAULT_SPEECH_TO_TEXT_MODEL,
+  DEFAULT_STS_MODEL: () => DEFAULT_STS_MODEL,
+  DEFAULT_TTS_MODEL: () => DEFAULT_TTS_MODEL,
   DEFAULT_TWILIO_BASE_URL: () => DEFAULT_TWILIO_BASE_URL,
   DEFAULT_VOICE_SETTINGS: () => DEFAULT_VOICE_SETTINGS,
   DirectTelephonyClient: () => DirectTelephonyClient,
@@ -38,28 +42,51 @@ __export(index_exports, {
   ElevenLabsClient: () => ElevenLabsClient,
   HostedRuntimeTokenClient: () => HostedRuntimeTokenClient,
   HostedTelephonyClient: () => HostedTelephonyClient,
+  LiveSession: () => LiveSession,
   MEMORY_CLIENT_TOOLS: () => MEMORY_CLIENT_TOOLS,
   MockTelephonyClient: () => MockTelephonyClient,
+  ShogoLiveClient: () => ShogoLiveClient,
+  TTS_FALLBACK_MODEL: () => TTS_FALLBACK_MODEL,
   TelephonyApiError: () => TelephonyApiError,
   TelephonyConfigError: () => TelephonyConfigError,
   TwilioApiError: () => TwilioApiError,
   TwilioClient: () => TwilioClient,
+  VOICE_OPS: () => VOICE_OPS,
+  VOICE_OP_IDS: () => VOICE_OP_IDS,
+  VOICE_SOUND_GENERATION_MODEL_IDS: () => VOICE_SOUND_GENERATION_MODEL_IDS,
+  VOICE_SPEECH_TO_TEXT_MODEL_IDS: () => VOICE_SPEECH_TO_TEXT_MODEL_IDS,
+  VOICE_STS_MODEL_IDS: () => VOICE_STS_MODEL_IDS,
+  VOICE_TTS_MODELS: () => VOICE_TTS_MODELS,
+  VOICE_TTS_MODEL_IDS: () => VOICE_TTS_MODEL_IDS,
   buildPreviewLine: () => buildPreviewLine,
   composeAgentPrompt: () => composeAgentPrompt,
   composeExpressivityBlock: () => composeExpressivityBlock,
   createTelephonyClient: () => createTelephonyClient,
   extractBasePrompt: () => extractBasePrompt,
+  getVoiceOp: () => getVoiceOp,
+  getVoiceTtsModel: () => getVoiceTtsModel,
+  isModelRelatedTtsFailure: () => isModelRelatedTtsFailure,
   isVoiceMockEnv: () => isVoiceMockEnv,
   normalizeAudioTags: () => normalizeAudioTags,
   normalizeExpressivity: () => normalizeExpressivity,
   normalizeVoiceSettings: () => normalizeVoiceSettings,
+  parseVoiceOpForm: () => parseVoiceOpForm,
+  parseVoiceOpJsonBody: () => parseVoiceOpJsonBody,
   readAudioTags: () => readAudioTags,
   readExpressivity: () => readExpressivity,
   readVoiceSettings: () => readVoiceSettings,
   resolveConvaiTtsModel: () => resolveConvaiTtsModel,
+  resolveConvaiTtsModelDetailed: () => resolveConvaiTtsModelDetailed,
   stripAudioTags: () => stripAudioTags,
   stripExpressivityBlock: () => stripExpressivityBlock,
-  stripMemoryBlock: () => stripMemoryBlock
+  stripMemoryBlock: () => stripMemoryBlock,
+  voiceOpCredentialError: () => voiceOpCredentialError,
+  voiceOpForwardPath: () => voiceOpForwardPath,
+  voiceOpIsMultipart: () => voiceOpIsMultipart,
+  voiceOpPathParams: () => voiceOpPathParams,
+  voiceOpReturnsAudio: () => voiceOpReturnsAudio,
+  voiceOpUpstreamBody: () => voiceOpUpstreamBody,
+  voiceOpUpstreamPath: () => voiceOpUpstreamPath
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -237,19 +264,74 @@ function composeAgentPrompt(basePrompt, options = {}) {
 
 // src/elevenlabs.ts
 var DEFAULT_ELEVENLABS_BASE_URL = "https://api.elevenlabs.io";
-var CONVAI_SUPPORTED_TTS_MODELS = /* @__PURE__ */ new Set([
-  "eleven_turbo_v2",
-  "eleven_turbo_v2_5",
-  "eleven_flash_v2",
-  "eleven_flash_v2_5",
-  "eleven_multilingual_v2"
-]);
-var CONVAI_TTS_MODEL_FALLBACK = "eleven_turbo_v2_5";
+var VOICE_TTS_MODELS = [
+  { id: "eleven_v4", label: "Eleven v4", realtime: false, maxChars: 1e4 },
+  { id: "eleven_v4_turbo", label: "Eleven v4 Turbo", realtime: true, maxChars: 1e4 },
+  { id: "eleven_v3", label: "Eleven v3", realtime: false, maxChars: 5e3 },
+  {
+    id: "eleven_v3_conversational",
+    label: "Eleven v3 Conversational",
+    realtime: true,
+    maxChars: 5e3
+  },
+  { id: "eleven_multilingual_v2", label: "Eleven Multilingual v2", realtime: false, maxChars: 1e4 },
+  { id: "eleven_flash_v2_5", label: "Eleven Flash v2.5", realtime: true, maxChars: 4e4 },
+  { id: "eleven_flash_v2", label: "Eleven Flash v2", realtime: true, maxChars: 3e4 },
+  { id: "eleven_turbo_v2_5", label: "Eleven Turbo v2.5", realtime: true, maxChars: 4e4 },
+  { id: "eleven_turbo_v2", label: "Eleven Turbo v2", realtime: true, maxChars: 3e4, deprecated: true }
+];
+var VOICE_TTS_MODEL_IDS = VOICE_TTS_MODELS.map((m) => m.id);
+var DEFAULT_TTS_MODEL = "eleven_v4";
+var CONVAI_SUPPORTED_TTS_MODELS = new Set(
+  VOICE_TTS_MODELS.filter((m) => m.realtime).map((m) => m.id)
+);
+var CONVAI_TTS_MODEL_FALLBACK = "eleven_v4_turbo";
+var TTS_FALLBACK_MODEL = "eleven_flash_v2_5";
+function getVoiceTtsModel(modelId) {
+  if (!modelId) return void 0;
+  return VOICE_TTS_MODELS.find((m) => m.id === modelId);
+}
+var loggedDowngrades = /* @__PURE__ */ new Set();
+function resolveConvaiTtsModelDetailed(requested) {
+  if (requested && CONVAI_SUPPORTED_TTS_MODELS.has(requested)) {
+    return { modelId: requested, requested, downgraded: false };
+  }
+  const known = getVoiceTtsModel(requested);
+  const reason = !requested ? void 0 : known ? `${requested} is not supported by the convai realtime runtime` : `unknown TTS model ${requested}`;
+  if (reason && !loggedDowngrades.has(requested)) {
+    loggedDowngrades.add(requested);
+    try {
+      console.warn(
+        `[voice] convai TTS model ${requested} is unavailable (${reason}); using ${CONVAI_TTS_MODEL_FALLBACK}`
+      );
+    } catch {
+    }
+  }
+  return {
+    modelId: CONVAI_TTS_MODEL_FALLBACK,
+    requested: requested ?? null,
+    downgraded: Boolean(requested),
+    ...reason ? { reason } : {}
+  };
+}
 function resolveConvaiTtsModel(requested) {
-  if (requested && CONVAI_SUPPORTED_TTS_MODELS.has(requested)) return requested;
-  return CONVAI_TTS_MODEL_FALLBACK;
+  return resolveConvaiTtsModelDetailed(requested).modelId;
+}
+function isModelRelatedTtsFailure(status, body) {
+  if (status === 402) return true;
+  if (status !== 400 && status !== 403 && status !== 404 && status !== 422) return false;
+  return /model|plan|permission/i.test(body);
 }
 var DEFAULT_MUSIC_MODEL = "music_v1";
+var VOICE_STS_MODEL_IDS = [
+  "eleven_multilingual_sts_v2",
+  "eleven_english_sts_v2"
+];
+var DEFAULT_STS_MODEL = "eleven_multilingual_sts_v2";
+var VOICE_SPEECH_TO_TEXT_MODEL_IDS = ["scribe_v1"];
+var DEFAULT_SPEECH_TO_TEXT_MODEL = "scribe_v1";
+var VOICE_SOUND_GENERATION_MODEL_IDS = ["eleven_text_to_sound_v2"];
+var DEFAULT_SOUND_GENERATION_MODEL = "eleven_text_to_sound_v2";
 var ElevenLabsApiError = class extends Error {
   constructor(message, status, body) {
     super(message);
@@ -414,12 +496,18 @@ var ElevenLabsClient = class {
     return data.signed_url;
   }
   /**
-   * One-shot TTS. Returns the raw audio bytes plus the model id that was
-   * actually used (some models aren't available for every account, so we
-   * fall back to `eleven_turbo_v2_5` on the first failure).
+   * One-shot TTS. Returns the raw audio bytes plus the model that actually
+   * produced them.
+   *
+   * The requested model is never swapped silently: we only retry on
+   * {@link TTS_FALLBACK_MODEL} when the failure is plausibly about
+   * the model (400/403/404/422 whose body mentions model/plan/permission,
+   * or 402 for an out-of-plan model). Auth (401), rate limit (429), 5xx and
+   * network errors are surfaced as-is. When a fallback does happen the
+   * result reports `requestedModel`, `fellBack` and `fallbackReason`.
    */
   async textToSpeech(params) {
-    const modelId = params.modelId && params.modelId.length > 0 ? params.modelId : "eleven_v3";
+    const requestedModel = params.modelId && params.modelId.length > 0 ? params.modelId : DEFAULT_TTS_MODEL;
     const accept = params.accept ?? "audio/mpeg";
     const attempt = async (m) => {
       const res2 = await this.fetchImpl(
@@ -436,19 +524,39 @@ var ElevenLabsClient = class {
       );
       return res2;
     };
-    let res = await attempt(modelId);
-    let used = modelId;
-    if (!res.ok && modelId !== "eleven_turbo_v2_5") {
-      res = await attempt("eleven_turbo_v2_5");
-      used = "eleven_turbo_v2_5";
-    }
+    let res = await attempt(requestedModel);
+    let used = requestedModel;
+    let fellBack = false;
+    let fallbackReason;
     if (!res.ok) {
-      const text = await res.text();
-      throw new ElevenLabsApiError(`textToSpeech failed: ${res.status}`, res.status, text);
+      const body = await res.text();
+      if (requestedModel !== TTS_FALLBACK_MODEL && isModelRelatedTtsFailure(res.status, body)) {
+        fallbackReason = `elevenlabs ${res.status} for ${requestedModel}: ${body.slice(0, 200)}`;
+        res = await attempt(TTS_FALLBACK_MODEL);
+        used = TTS_FALLBACK_MODEL;
+        fellBack = true;
+        if (!res.ok) {
+          const retryBody = await res.text();
+          throw new ElevenLabsApiError(
+            `textToSpeech failed: ${res.status}`,
+            res.status,
+            retryBody
+          );
+        }
+      } else {
+        throw new ElevenLabsApiError(`textToSpeech failed: ${res.status}`, res.status, body);
+      }
     }
     const audio = await res.arrayBuffer();
     const contentType = res.headers.get("content-type") ?? accept;
-    return { audio, modelId: used, contentType };
+    return {
+      audio,
+      modelId: used,
+      requestedModel,
+      fellBack,
+      ...fallbackReason ? { fallbackReason } : {},
+      contentType
+    };
   }
   /**
    * Low-level escape hatch for any ElevenLabs endpoint not covered by a
@@ -554,6 +662,119 @@ var ElevenLabsClient = class {
     }
     return { audio, contentType };
   }
+  /**
+   * Convert speech to speech — the "voice changer": keep the performance,
+   * swap the voice. `POST /v1/speech-to-speech/{voiceId}` with a multipart
+   * audio part. Returns the converted audio bytes.
+   *
+   * @example
+   * ```ts
+   * const { audio } = await el.speechToSpeech({
+   *   voiceId: '21m00Tcm4TlvDq8ikWAM',
+   *   audio: await fetch(myRecording).then((r) => r.blob()),
+   *   modelId: 'eleven_multilingual_sts_v2',
+   * })
+   * ```
+   */
+  async speechToSpeech(params) {
+    if (!params.voiceId) throw new Error("speechToSpeech: voiceId is required");
+    if (!params.audio) throw new Error("speechToSpeech: audio is required");
+    const form = new FormData();
+    form.set("audio", params.audio, params.fileName ?? "audio");
+    form.set("model_id", params.modelId ?? DEFAULT_STS_MODEL);
+    if (params.voiceSettings) {
+      form.set("voice_settings", JSON.stringify(params.voiceSettings));
+    }
+    if (params.outputFormat) form.set("output_format", params.outputFormat);
+    if (params.fileFormat) form.set("file_format", params.fileFormat);
+    if (params.seed !== void 0) form.set("seed", String(params.seed));
+    if (params.removeBackgroundNoise !== void 0) {
+      form.set("remove_background_noise", String(params.removeBackgroundNoise));
+    }
+    const { audio, contentType } = await this.request({
+      method: "POST",
+      path: `/v1/speech-to-speech/${encodeURIComponent(params.voiceId)}`,
+      body: form,
+      accept: "audio/mpeg"
+    });
+    if (!audio) {
+      throw new ElevenLabsApiError(
+        "speechToSpeech: expected audio bytes but got a JSON response",
+        500,
+        ""
+      );
+    }
+    return { audio, contentType };
+  }
+  /**
+   * Generate a sound effect from a text prompt. `POST /v1/sound-generation`.
+   *
+   * @example
+   * ```ts
+   * const { audio } = await el.soundEffects({ text: 'heavy wooden door creaking' })
+   * ```
+   */
+  async soundEffects(params) {
+    if (!params.text || !params.text.trim()) {
+      throw new Error("soundEffects: text is required");
+    }
+    const body = {
+      text: params.text,
+      model_id: params.modelId ?? DEFAULT_SOUND_GENERATION_MODEL
+    };
+    if (params.durationSeconds !== void 0) body.duration_seconds = params.durationSeconds;
+    if (params.promptInfluence !== void 0) body.prompt_influence = params.promptInfluence;
+    if (params.loop !== void 0) body.loop = params.loop;
+    const { audio, contentType } = await this.request({
+      method: "POST",
+      path: "/v1/sound-generation",
+      body,
+      accept: "audio/mpeg",
+      ...params.outputFormat ? { query: { output_format: params.outputFormat } } : {}
+    });
+    if (!audio) {
+      throw new ElevenLabsApiError(
+        "soundEffects: expected audio bytes but got a JSON response",
+        500,
+        ""
+      );
+    }
+    return { audio, contentType };
+  }
+  /**
+   * Transcribe audio with Scribe. `POST /v1/speech-to-text` (multipart).
+   *
+   * @example
+   * ```ts
+   * const { text } = await el.transcribe({ file: recording })
+   * ```
+   */
+  async transcribe(params) {
+    if (!params.file) throw new Error("transcribe: file is required");
+    const form = new FormData();
+    form.set("file", params.file, params.fileName ?? "audio");
+    form.set("model_id", params.modelId ?? DEFAULT_SPEECH_TO_TEXT_MODEL);
+    if (params.languageCode) form.set("language_code", params.languageCode);
+    if (params.diarize !== void 0) form.set("diarize", String(params.diarize));
+    if (params.tagAudioEvents !== void 0) {
+      form.set("tag_audio_events", String(params.tagAudioEvents));
+    }
+    if (params.numSpeakers !== void 0) form.set("num_speakers", String(params.numSpeakers));
+    const { json } = await this.request({
+      method: "POST",
+      path: "/v1/speech-to-text",
+      body: form,
+      accept: "application/json"
+    });
+    if (!json || typeof json !== "object") {
+      throw new ElevenLabsApiError(
+        "transcribe: expected a JSON transcription but got audio",
+        500,
+        ""
+      );
+    }
+    return json;
+  }
   /** Probe whether a given voice id still exists on the caller's account. */
   async voiceExists(voiceId) {
     const res = await this.fetchImpl(
@@ -717,6 +938,325 @@ var MEMORY_CLIENT_TOOLS = [
   }
 ];
 
+// src/ops.ts
+var MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+var MAX_JSON_BYTES = 8 * 1024;
+var MAX_TEXT_BYTES = 256 * 1024;
+var VOICE_OPS = [
+  {
+    id: "text-to-speech",
+    method: "POST",
+    hostedPath: "/voice/op/text-to-speech",
+    legacyHostedPath: "/voice/tts",
+    upstreamPath: "/v1/text-to-speech/{voiceId}",
+    pathParams: ["voiceId"],
+    transport: "json-binary",
+    call: "textToSpeech",
+    permission: "project:read",
+    maxBodyBytes: MAX_TEXT_BYTES,
+    cost: { unit: "character", per: 1 },
+    models: VOICE_TTS_MODEL_IDS,
+    defaultModel: CONVAI_TTS_MODEL_FALLBACK,
+    defaultVoiceId: true,
+    forward: {
+      text: "text",
+      voiceId: "voice_id",
+      modelId: "model_id",
+      voiceSettings: "voice_settings"
+    },
+    required: ["text"],
+    responseHeaders: ["x-tts-model-used", "x-tts-model-requested", "warning"],
+    accept: "audio/mpeg",
+    errorLabel: "TTS failed"
+  },
+  {
+    id: "text-to-speech-with-timestamps",
+    method: "POST",
+    hostedPath: "/voice/op/text-to-speech-with-timestamps",
+    upstreamPath: "/v1/text-to-speech/{voiceId}/with-timestamps",
+    pathParams: ["voiceId"],
+    transport: "json-json",
+    permission: "project:read",
+    maxBodyBytes: MAX_TEXT_BYTES,
+    cost: { unit: "character", per: 1 },
+    models: VOICE_TTS_MODEL_IDS,
+    defaultModel: CONVAI_TTS_MODEL_FALLBACK,
+    defaultVoiceId: true,
+    forward: {
+      text: "text",
+      voiceId: "voice_id",
+      modelId: "model_id",
+      voiceSettings: "voice_settings",
+      outputFormat: "output_format"
+    },
+    required: ["text"],
+    accept: "application/json"
+  },
+  {
+    id: "speech-to-speech",
+    method: "POST",
+    hostedPath: "/voice/op/speech-to-speech",
+    upstreamPath: "/v1/speech-to-speech/{voiceId}",
+    pathParams: ["voiceId"],
+    transport: "multipart-binary",
+    permission: "project:read",
+    maxBodyBytes: MAX_AUDIO_BYTES,
+    cost: { unit: "second", per: 1 },
+    models: VOICE_STS_MODEL_IDS,
+    defaultModel: DEFAULT_STS_MODEL,
+    defaultVoiceId: true,
+    forward: {
+      audio: "audio",
+      voiceId: "voice_id",
+      modelId: "model_id",
+      voiceSettings: "voice_settings",
+      outputFormat: "output_format",
+      fileFormat: "file_format",
+      seed: "seed",
+      removeBackgroundNoise: "remove_background_noise"
+    },
+    required: ["audio"],
+    accept: "audio/mpeg"
+  },
+  {
+    id: "speech-to-text",
+    method: "POST",
+    hostedPath: "/voice/op/speech-to-text",
+    upstreamPath: "/v1/speech-to-text",
+    transport: "multipart-json",
+    permission: "project:read",
+    maxBodyBytes: MAX_AUDIO_BYTES,
+    cost: { unit: "second", per: 1 },
+    models: VOICE_SPEECH_TO_TEXT_MODEL_IDS,
+    defaultModel: DEFAULT_SPEECH_TO_TEXT_MODEL,
+    forward: {
+      file: "file",
+      modelId: "model_id",
+      languageCode: "language_code",
+      diarize: "diarize",
+      tagAudioEvents: "tag_audio_events",
+      numSpeakers: "num_speakers"
+    },
+    required: ["file"],
+    accept: "application/json"
+  },
+  {
+    id: "sound-generation",
+    method: "POST",
+    hostedPath: "/voice/op/sound-generation",
+    upstreamPath: "/v1/sound-generation",
+    transport: "json-binary",
+    permission: "project:read",
+    maxBodyBytes: MAX_JSON_BYTES,
+    cost: { unit: "second", per: 1 },
+    models: VOICE_SOUND_GENERATION_MODEL_IDS,
+    defaultModel: DEFAULT_SOUND_GENERATION_MODEL,
+    forward: {
+      text: "text",
+      durationSeconds: "duration_seconds",
+      promptInfluence: "prompt_influence",
+      loop: "loop",
+      modelId: "model_id"
+    },
+    // `output_format` is a query param on this endpoint, not a body field — the
+    // typed `soundEffects()` client sends it there, and a body field is
+    // silently ignored upstream.
+    queryForward: ["output_format"],
+    required: ["text"],
+    accept: "audio/mpeg"
+  },
+  {
+    id: "music",
+    method: "POST",
+    hostedPath: "/voice/op/music",
+    legacyHostedPath: "/voice/music",
+    upstreamPath: "/v1/music",
+    transport: "json-binary",
+    call: "composeMusic",
+    permission: "project:read",
+    maxBodyBytes: MAX_JSON_BYTES,
+    cost: { unit: "second", per: 1 },
+    models: [DEFAULT_MUSIC_MODEL],
+    defaultModel: DEFAULT_MUSIC_MODEL,
+    forward: {
+      prompt: "prompt",
+      compositionPlan: "composition_plan",
+      musicLengthMs: "music_length_ms",
+      modelId: "model_id",
+      forceInstrumental: "force_instrumental",
+      outputFormat: "output_format"
+    },
+    accept: "audio/mpeg",
+    errorLabel: "Music generation failed",
+    validate: (fields) => {
+      const hasPrompt = typeof fields.prompt === "string" && fields.prompt.trim().length > 0;
+      const hasPlan = fields.compositionPlan != null && typeof fields.compositionPlan === "object";
+      return hasPrompt === hasPlan ? "Provide exactly one of `prompt` or `compositionPlan`" : null;
+    }
+  },
+  {
+    id: "voices",
+    method: "GET",
+    hostedPath: "/voice/op/voices",
+    upstreamPath: "/v1/voices",
+    transport: "json-json",
+    permission: "project:read",
+    maxBodyBytes: 0,
+    cost: { unit: "request", per: 1 },
+    queryForward: ["page_size", "search", "voice_type", "category", "next_page_token"],
+    accept: "application/json"
+  },
+  {
+    id: "models",
+    method: "GET",
+    hostedPath: "/voice/op/models",
+    upstreamPath: "/v1/models",
+    transport: "json-json",
+    permission: "project:read",
+    maxBodyBytes: 0,
+    cost: { unit: "request", per: 1 },
+    accept: "application/json"
+  }
+];
+var VOICE_OP_IDS = VOICE_OPS.map((op) => op.id);
+function getVoiceOp(id) {
+  if (!id) return void 0;
+  return VOICE_OPS.find((op) => op.id === id);
+}
+function voiceOpForwardPath(op) {
+  return op.legacyHostedPath ?? op.hostedPath;
+}
+function voiceOpIsMultipart(op) {
+  return op.transport === "multipart-binary" || op.transport === "multipart-json";
+}
+function voiceOpReturnsAudio(op) {
+  return op.transport === "json-binary" || op.transport === "multipart-binary";
+}
+function voiceOpUpstreamPath(op, params) {
+  let path = op.upstreamPath;
+  for (const name of op.pathParams ?? []) {
+    const value = params[name];
+    if (!value) {
+      return { error: `Missing \`${name}\` (required path parameter for ${op.id})` };
+    }
+    path = path.split(`{${name}}`).join(encodeURIComponent(value));
+  }
+  return path;
+}
+function voiceOpCredentialError(op, credential) {
+  if (op.byoOnly && credential === "pooled") {
+    return {
+      status: 403,
+      error: "byo_key_required",
+      detail: `${op.id} runs on your own ElevenLabs key, not Shogo's pooled key \u2014 pass it to ElevenLabsClient and call request() directly`
+    };
+  }
+  return null;
+}
+var MODEL_FIELD = "modelId";
+function parseVoiceOpJsonBody(op, raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, status: 400, error: "Invalid JSON body" };
+  }
+  const body = raw;
+  const fields = {};
+  for (const [callerField, upstreamField] of Object.entries(op.forward ?? {})) {
+    if (upstreamField && body[callerField] !== void 0) fields[callerField] = body[callerField];
+  }
+  for (const name of op.required ?? []) {
+    const value = fields[name];
+    if (value === void 0 || value === null || typeof value === "string" && !value.trim()) {
+      return { ok: false, status: 400, error: `Missing \`${name}\`` };
+    }
+  }
+  const modelCheck = checkVoiceOpModel(op, fields);
+  if ("error" in modelCheck) return { ok: false, status: 400, ...modelCheck };
+  if (op.validate) {
+    const message = op.validate(fields);
+    if (message) return { ok: false, status: 400, error: message };
+  }
+  return { ok: true, fields };
+}
+function parseVoiceOpForm(op, form) {
+  const fields = {};
+  for (const callerField of Object.keys(op.forward ?? {})) {
+    const value = form.get(callerField);
+    if (value !== null) fields[callerField] = value;
+  }
+  for (const name of op.required ?? []) {
+    const value = fields[name];
+    if (!(value instanceof Blob)) {
+      return {
+        ok: false,
+        status: 400,
+        error: `Missing \`${name}\` file part`,
+        detail: value === void 0 ? `send a multipart body with a \`${name}\` file part` : `\`${name}\` must be a file part, not a text field`
+      };
+    }
+    if (value.size === 0) {
+      return { ok: false, status: 400, error: `Empty \`${name}\` file part` };
+    }
+  }
+  const modelCheck = checkVoiceOpModel(op, fields);
+  if ("error" in modelCheck) return { ok: false, status: 400, ...modelCheck };
+  const forward = op.forward ?? {};
+  const pathParams = new Set(op.pathParams ?? []);
+  const out = new FormData();
+  for (const [callerField, upstreamField] of Object.entries(forward)) {
+    if (pathParams.has(callerField)) continue;
+    const value = fields[callerField];
+    if (value === void 0 || value === null || value === "") continue;
+    if (value instanceof Blob) {
+      const name = value instanceof File ? value.name : callerField;
+      out.set(upstreamField, value, name);
+    } else if (typeof value === "string") {
+      out.set(upstreamField, value);
+    } else {
+      out.set(upstreamField, JSON.stringify(value));
+    }
+  }
+  const modelField = forward[MODEL_FIELD];
+  if (op.defaultModel && modelField && out.get(modelField) === null) {
+    out.set(modelField, op.defaultModel);
+  }
+  return { ok: true, form: out, fields };
+}
+function voiceOpUpstreamBody(op, fields) {
+  const pathParams = new Set(op.pathParams ?? []);
+  const body = {};
+  for (const [callerField, upstreamField] of Object.entries(op.forward ?? {})) {
+    if (pathParams.has(callerField)) continue;
+    const value = fields[callerField];
+    if (value === void 0 || value === null) continue;
+    body[upstreamField] = value;
+  }
+  return body;
+}
+function voiceOpPathParams(op, fields, query) {
+  const out = {};
+  for (const name of op.pathParams ?? []) {
+    const fromBody = fields[name];
+    const value = typeof fromBody === "string" && fromBody.length > 0 ? fromBody : query.get(name);
+    if (value) out[name] = value;
+  }
+  return out;
+}
+function checkVoiceOpModel(op, fields) {
+  const requested = fields[MODEL_FIELD];
+  if (requested === void 0 || requested === null || requested === "") return { ok: true };
+  if (typeof requested !== "string") {
+    return { error: `\`${MODEL_FIELD}\` must be a string` };
+  }
+  if (op.models && !op.models.includes(requested)) {
+    return {
+      error: "unknown_model",
+      detail: `Unknown model '${requested}' for ${op.id}`,
+      allowed: op.models
+    };
+  }
+  return { ok: true };
+}
+
 // src/twilio.ts
 var DEFAULT_TWILIO_BASE_URL = "https://api.twilio.com";
 var TwilioApiError = class extends Error {
@@ -1377,6 +1917,149 @@ function isVoiceMockEnv() {
   const v = value.toLowerCase();
   return v === "mock" || v === "demo" || v === "fake";
 }
+
+// src/live/client.ts
+function encodeAudio(audio) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < audio.length; i += 32768) {
+      binary += String.fromCharCode(...audio.subarray(i, i + 32768));
+    }
+    return btoa(binary);
+  }
+  const BufferImpl = globalThis.Buffer;
+  if (BufferImpl) return BufferImpl.from(audio).toString("base64");
+  throw new Error("Base64 encoding is unavailable in this runtime");
+}
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+var LiveSession = class {
+  constructor(socket, initialSession) {
+    this.socket = socket;
+    this.initialSession = initialSession;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.latestUsageSeconds = 0;
+    this.startedPromise = new Promise((resolve, reject) => {
+      this.resolveStarted = resolve;
+      this.rejectStarted = reject;
+    });
+    this.started = this.startedPromise;
+    this.closedPromise = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+    socket.addEventListener("message", (message) => {
+      const raw = typeof message.data === "string" ? message.data : "";
+      if (!raw) return;
+      let event;
+      try {
+        event = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (event.type === "session.started") this.resolveStarted(event);
+      if (event.type === "session.usage.updated") {
+        const seconds = event.usage?.seconds;
+        if (typeof seconds === "number") this.latestUsageSeconds = seconds;
+      }
+      if (event.type === "session.closed") {
+        this.closed = true;
+        this.resolveClosed(event);
+      }
+      if (event.type === "error" && !this.closed) {
+        const messageText = String(event.error?.message || "Live session error");
+        this.rejectStarted(new Error(messageText));
+      }
+      for (const handler of this.handlers.get(String(event.type)) ?? []) handler(event);
+      for (const handler of this.handlers.get("*") ?? []) handler(event);
+    });
+    socket.addEventListener("close", () => {
+      if (!this.closed) this.resolveClosed();
+    });
+    socket.addEventListener("error", () => {
+      if (!this.closed) this.rejectStarted(new Error("Live session WebSocket error"));
+    });
+    socket.addEventListener("open", () => {
+      if (initialSession) this.send({ type: "session.start", session: initialSession });
+    });
+  }
+  on(eventType, handler) {
+    const handlers = this.handlers.get(eventType) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.handlers.set(eventType, handlers);
+    return () => handlers.delete(handler);
+  }
+  send(event) {
+    if (this.closed) throw new Error("Live session is closed");
+    this.socket.send(JSON.stringify(event));
+  }
+  appendAudio(audio) {
+    this.send({
+      type: "session.input_audio.append",
+      audio: typeof audio === "string" ? audio : encodeAudio(audio)
+    });
+  }
+  async close(timeoutMs = 15e3) {
+    if (this.closed) return;
+    if (this.socket.readyState === 1) this.send({ type: "session.close" });
+    const timeout = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    const result = await Promise.race([this.closedPromise, timeout]);
+    if (!this.closed) this.socket.close();
+    return result;
+  }
+};
+var ShogoLiveClient = class {
+  constructor(options) {
+    if (!!options.apiKey === !!options.runtimeToken) {
+      throw new Error("ShogoLiveClient requires exactly one of apiKey or runtimeToken.");
+    }
+    this.apiUrl = normalizeBaseUrl(options.apiUrl);
+    this.token = options.apiKey ?? options.runtimeToken;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.WebSocketImpl = options.WebSocket ?? globalThis.WebSocket;
+    if (typeof this.fetchImpl !== "function") throw new Error("fetch is unavailable");
+    if (typeof this.WebSocketImpl !== "function") throw new Error("WebSocket is unavailable");
+  }
+  httpUrl(path) {
+    return `${this.apiUrl}${path}`;
+  }
+  wsUrl(path) {
+    return this.httpUrl(path).replace(/^http/, "ws");
+  }
+  protocols() {
+    return ["shogo-live", `shogo-insecure-api-key.${this.token}`];
+  }
+  connect(session) {
+    const socket = new this.WebSocketImpl(this.wsUrl("/api/ai/v1/live/sessions"), this.protocols());
+    return new LiveSession(socket, session);
+  }
+  attach(sessionId) {
+    const socket = new this.WebSocketImpl(
+      this.wsUrl(`/api/ai/v1/live/sessions/${encodeURIComponent(sessionId)}/attach`),
+      this.protocols()
+    );
+    return new LiveSession(socket);
+  }
+  async createWebRtcSession(input) {
+    const response = await this.fetchImpl(this.httpUrl("/api/ai/v1/live/sessions"), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        session: input.session,
+        transport: { type: "webrtc", sdp: input.sdp }
+      })
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      throw new Error(body?.error?.message || `Live session creation failed (${response.status})`);
+    }
+    return body;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AUDIO_TAGS,
@@ -1387,6 +2070,10 @@ function isVoiceMockEnv() {
   DEFAULT_ELEVENLABS_BASE_URL,
   DEFAULT_MEMORY_BLOCK,
   DEFAULT_MUSIC_MODEL,
+  DEFAULT_SOUND_GENERATION_MODEL,
+  DEFAULT_SPEECH_TO_TEXT_MODEL,
+  DEFAULT_STS_MODEL,
+  DEFAULT_TTS_MODEL,
   DEFAULT_TWILIO_BASE_URL,
   DEFAULT_VOICE_SETTINGS,
   DirectTelephonyClient,
@@ -1397,27 +2084,50 @@ function isVoiceMockEnv() {
   ElevenLabsClient,
   HostedRuntimeTokenClient,
   HostedTelephonyClient,
+  LiveSession,
   MEMORY_CLIENT_TOOLS,
   MockTelephonyClient,
+  ShogoLiveClient,
+  TTS_FALLBACK_MODEL,
   TelephonyApiError,
   TelephonyConfigError,
   TwilioApiError,
   TwilioClient,
+  VOICE_OPS,
+  VOICE_OP_IDS,
+  VOICE_SOUND_GENERATION_MODEL_IDS,
+  VOICE_SPEECH_TO_TEXT_MODEL_IDS,
+  VOICE_STS_MODEL_IDS,
+  VOICE_TTS_MODELS,
+  VOICE_TTS_MODEL_IDS,
   buildPreviewLine,
   composeAgentPrompt,
   composeExpressivityBlock,
   createTelephonyClient,
   extractBasePrompt,
+  getVoiceOp,
+  getVoiceTtsModel,
+  isModelRelatedTtsFailure,
   isVoiceMockEnv,
   normalizeAudioTags,
   normalizeExpressivity,
   normalizeVoiceSettings,
+  parseVoiceOpForm,
+  parseVoiceOpJsonBody,
   readAudioTags,
   readExpressivity,
   readVoiceSettings,
   resolveConvaiTtsModel,
+  resolveConvaiTtsModelDetailed,
   stripAudioTags,
   stripExpressivityBlock,
-  stripMemoryBlock
+  stripMemoryBlock,
+  voiceOpCredentialError,
+  voiceOpForwardPath,
+  voiceOpIsMultipart,
+  voiceOpPathParams,
+  voiceOpReturnsAudio,
+  voiceOpUpstreamBody,
+  voiceOpUpstreamPath
 });
 //# sourceMappingURL=index.cjs.map