@shogo-ai/voice 1.10.0 → 2.4.2

package/dist/chunk-IOFWML5L.js

@@ -0,0 +1,1078 @@
+import {
+  composeExpressivityBlock,
+  stripExpressivityBlock
+} from "./chunk-Q3TJAJ54.js";
+
+// src/prompt.ts
+var DEFAULT_MEMORY_BLOCK = `# Memory
+
+Known context about this user from past conversations:
+{{user_context}}
+
+Memory retrieval is automatic \u2014 the top matching facts are already injected above. Never say "let me check my memory" or "searching memories."
+
+You have one tool:
+- add_memory(fact): save a concise, canonical fact about the user \u2014 preferences, decisions, personal details, follow-ups. Use short normalized phrasings like "favorite color: green" or "lives in Honolulu". Always call it when the user explicitly asks you to remember something.`;
+function stripMemoryBlock(prompt) {
+  if (!prompt) return prompt;
+  return prompt.replace(/\n*<!-- zix-memory-v\d+ -->[\s\S]*$/m, "").replace(/\n*# Memory\s*\n\s*Known context about this user[\s\S]*$/m, "").trimEnd();
+}
+function extractBasePrompt(prompt) {
+  return stripExpressivityBlock(stripMemoryBlock(prompt));
+}
+function composeAgentPrompt(basePrompt, options = {}) {
+  const { expressivity = "subtle", audioTags = null, memoryBlock = DEFAULT_MEMORY_BLOCK } = options;
+  const stripped = extractBasePrompt(basePrompt);
+  const expr = composeExpressivityBlock(expressivity, audioTags);
+  const parts = [stripped];
+  if (expr) parts.push(expr);
+  if (memoryBlock) parts.push(memoryBlock);
+  return parts.join("\n\n");
+}
+
+// src/elevenlabs.ts
+var DEFAULT_ELEVENLABS_BASE_URL = "https://api.elevenlabs.io";
+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) {
+  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);
+    this.status = status;
+    this.body = body;
+    this.name = "ElevenLabsApiError";
+  }
+};
+var ElevenLabsClient = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.apiKey) throw new Error("ElevenLabsClient: apiKey is required");
+    this.baseUrl = (config.baseUrl ?? DEFAULT_ELEVENLABS_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = config.fetch ?? globalThis.fetch;
+    if (typeof this.fetchImpl !== "function") {
+      throw new Error("ElevenLabsClient: global fetch is unavailable; pass config.fetch");
+    }
+  }
+  headers(extra = {}) {
+    return {
+      "xi-api-key": this.config.apiKey,
+      ...extra
+    };
+  }
+  /** Create a new convai agent. Returns the new `agent_id`. */
+  async createAgent(params) {
+    const prompt = composeAgentPrompt(params.systemPrompt, {
+      expressivity: params.expressivity ?? "subtle",
+      audioTags: params.audioTags ?? null,
+      memoryBlock: params.memoryBlock
+    });
+    const ttsConfig = {
+      voice_id: params.voiceId,
+      model_id: resolveConvaiTtsModel(params.ttsModelId)
+    };
+    if (params.voiceSettings) ttsConfig.voice_settings = params.voiceSettings;
+    const body = {
+      name: `Companion-${params.characterName}-for-${params.displayName}`,
+      conversation_config: {
+        agent: {
+          prompt: {
+            prompt,
+            ...params.tools ? { tools: params.tools } : {}
+          },
+          first_message: params.firstMessage,
+          language: params.language ?? "en"
+        },
+        tts: ttsConfig
+      },
+      platform_settings: {
+        overrides: {
+          conversation_config_override: {
+            agent: { prompt: { prompt: true }, first_message: true, language: true },
+            tts: { voice_id: true },
+            conversation: { text_only: true }
+          }
+        },
+        dynamic_variables: {
+          dynamic_variable_placeholders: {
+            user_context: "No prior memories yet.",
+            character_name: "",
+            ...params.dynamicVariablePlaceholders ?? {}
+          }
+        }
+      }
+    };
+    const res = await this.fetchImpl(`${this.baseUrl}/v1/convai/agents/create`, {
+      method: "POST",
+      headers: this.headers({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(`createAgent failed: ${res.status}`, res.status, text);
+    }
+    const data = await res.json();
+    return data.agent_id;
+  }
+  /** PATCH any subset of agent settings. Idempotent; only sends the keys you supply. */
+  async patchAgent(agentId, params) {
+    const body = {};
+    if (params.displayName !== void 0 || params.characterName !== void 0) {
+      body.name = `Companion-${params.characterName ?? ""}-for-${params.displayName ?? ""}`.replace(
+        /-for-$/,
+        ""
+      );
+    }
+    const conv = {};
+    const agent = {};
+    const prompt = {};
+    if (params.systemPrompt !== void 0) {
+      prompt.prompt = composeAgentPrompt(params.systemPrompt, {
+        expressivity: params.expressivity ?? "subtle",
+        audioTags: params.audioTags ?? null,
+        memoryBlock: params.memoryBlock
+      });
+    }
+    if (params.tools) prompt.tools = params.tools;
+    if (Object.keys(prompt).length) agent.prompt = prompt;
+    if (params.firstMessage !== void 0) agent.first_message = params.firstMessage;
+    if (Object.keys(agent).length) conv.agent = agent;
+    const tts = {};
+    if (params.voiceId !== void 0) tts.voice_id = params.voiceId;
+    if (params.voiceSettings) tts.voice_settings = params.voiceSettings;
+    if (params.ttsModelId !== void 0) tts.model_id = resolveConvaiTtsModel(params.ttsModelId);
+    if (Object.keys(tts).length) conv.tts = tts;
+    if (Object.keys(conv).length) body.conversation_config = conv;
+    if (params.enableUserContextOverride) {
+      body.platform_settings = {
+        overrides: {
+          conversation_config_override: {
+            agent: { prompt: { prompt: true }, first_message: true, language: true },
+            tts: { voice_id: true },
+            conversation: { text_only: true }
+          },
+          custom_llm_extra_body: false,
+          enable_conversation_initiation_client_data_from_webhook: false
+        },
+        dynamic_variables: {
+          dynamic_variable_placeholders: {
+            user_context: "No prior memories yet.",
+            character_name: ""
+          }
+        }
+      };
+    }
+    if (!Object.keys(body).length) return;
+    const res = await this.fetchImpl(`${this.baseUrl}/v1/convai/agents/${encodeURIComponent(agentId)}`, {
+      method: "PATCH",
+      headers: this.headers({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(`patchAgent failed: ${res.status}`, res.status, text);
+    }
+  }
+  /**
+   * Delete a convai agent. Best-effort: swallow errors so teardown during a
+   * 500 response doesn't cascade into a second failure.
+   */
+  async deleteAgent(agentId) {
+    try {
+      await this.fetchImpl(`${this.baseUrl}/v1/convai/agents/${encodeURIComponent(agentId)}`, {
+        method: "DELETE",
+        headers: this.headers()
+      });
+    } catch {
+    }
+  }
+  /** Fetch a short-lived signed URL the browser can use to start a session. */
+  async getSignedUrl(agentId) {
+    const res = await this.fetchImpl(
+      `${this.baseUrl}/v1/convai/conversation/get-signed-url?agent_id=${encodeURIComponent(agentId)}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(`getSignedUrl failed: ${res.status}`, res.status, text);
+    }
+    const data = await res.json();
+    return data.signed_url;
+  }
+  /**
+   * 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 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(
+        `${this.baseUrl}/v1/text-to-speech/${encodeURIComponent(params.voiceId)}`,
+        {
+          method: "POST",
+          headers: this.headers({ "content-type": "application/json", accept }),
+          body: JSON.stringify({
+            text: params.text,
+            model_id: m,
+            voice_settings: params.voiceSettings
+          })
+        }
+      );
+      return res2;
+    };
+    let res = await attempt(requestedModel);
+    let used = requestedModel;
+    let fellBack = false;
+    let fallbackReason;
+    if (!res.ok) {
+      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,
+      requestedModel,
+      fellBack,
+      ...fallbackReason ? { fallbackReason } : {},
+      contentType
+    };
+  }
+  /**
+   * Low-level escape hatch for any ElevenLabs endpoint not covered by a
+   * dedicated method (music, sound-generation, speech-to-text, dubbing,
+   * voice-design, …). Handles auth, query encoding, JSON body encoding,
+   * and JSON-vs-binary response parsing; non-2xx responses throw
+   * {@link ElevenLabsApiError} like the typed methods do.
+   *
+   * @example
+   * ```ts
+   * const { json } = await el.request({ method: 'GET', path: '/v1/models' })
+   * const { audio } = await el.request({
+   *   method: 'POST',
+   *   path: '/v1/sound-generation',
+   *   body: { text: 'door creak' },
+   *   accept: 'audio/mpeg',
+   * })
+   * ```
+   */
+  async request(opts) {
+    const accept = opts.accept ?? "application/json";
+    let url = `${this.baseUrl}${opts.path.startsWith("/") ? "" : "/"}${opts.path}`;
+    if (opts.query) {
+      const params = new URLSearchParams();
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== null && v !== void 0) params.set(k, String(v));
+      }
+      const qs = params.toString();
+      if (qs) url += `${url.includes("?") ? "&" : "?"}${qs}`;
+    }
+    const headers = this.headers({ accept, ...opts.headers ?? {} });
+    const init = { method: opts.method, headers };
+    if (opts.body !== void 0 && opts.body !== null) {
+      const isPlainPayload = typeof opts.body === "object" && !(opts.body instanceof ArrayBuffer) && !(opts.body instanceof Uint8Array) && !(typeof Blob !== "undefined" && opts.body instanceof Blob) && !(typeof FormData !== "undefined" && opts.body instanceof FormData);
+      if (isPlainPayload) {
+        headers["content-type"] = "application/json";
+        init.body = JSON.stringify(opts.body);
+      } else {
+        init.body = opts.body;
+      }
+    }
+    const res = await this.fetchImpl(url, init);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(
+        `request ${opts.method} ${opts.path} failed: ${res.status}`,
+        res.status,
+        text
+      );
+    }
+    const contentType = res.headers.get("content-type") ?? accept;
+    if (contentType.includes("application/json")) {
+      return { status: res.status, contentType, json: await res.json() };
+    }
+    return { status: res.status, contentType, audio: await res.arrayBuffer() };
+  }
+  /**
+   * Generate music via `POST /v1/music`. Provide exactly one of `prompt`
+   * or `compositionPlan` (ElevenLabs returns 422 otherwise). Returns the
+   * raw audio bytes plus the response content type.
+   *
+   * @example
+   * ```ts
+   * const { audio } = await el.composeMusic({
+   *   prompt: 'Upbeat synthwave with driving bass',
+   *   musicLengthMs: 30_000,
+   * })
+   * ```
+   */
+  async composeMusic(params) {
+    const hasPrompt = typeof params.prompt === "string" && params.prompt.length > 0;
+    const hasPlan = params.compositionPlan != null;
+    if (hasPrompt === hasPlan) {
+      throw new Error(
+        "composeMusic: provide exactly one of `prompt` or `compositionPlan`"
+      );
+    }
+    const body = {
+      model_id: params.modelId ?? DEFAULT_MUSIC_MODEL
+    };
+    if (hasPrompt) {
+      body.prompt = params.prompt;
+      if (params.musicLengthMs !== void 0) body.music_length_ms = params.musicLengthMs;
+      if (params.forceInstrumental !== void 0) {
+        body.force_instrumental = params.forceInstrumental;
+      }
+    } else {
+      body.composition_plan = params.compositionPlan;
+    }
+    const { audio, contentType } = await this.request({
+      method: "POST",
+      path: "/v1/music",
+      body,
+      accept: "audio/mpeg",
+      ...params.outputFormat ? { query: { output_format: params.outputFormat } } : {}
+    });
+    if (!audio) {
+      throw new ElevenLabsApiError(
+        "composeMusic: expected audio bytes but got a JSON response",
+        500,
+        ""
+      );
+    }
+    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(
+      `${this.baseUrl}/v1/voices/${encodeURIComponent(voiceId)}`,
+      { headers: this.headers() }
+    );
+    return res.ok;
+  }
+  /**
+   * Register a Twilio phone number with an ElevenLabs agent. EL becomes
+   * the SIP target for inbound calls to that number — Twilio bridges
+   * the call via EL's native integration and we never have to run a
+   * Media Streams ↔ convai WebSocket bridge ourselves.
+   *
+   * Returns the ElevenLabs `phone_number_id` (distinct from the Twilio
+   * `sid`) which is the handle used by `outboundCall` + `deletePhoneNumber`.
+   */
+  async createPhoneNumberTwilio(params) {
+    const body = {
+      phone_number: params.phoneNumber,
+      label: params.label ?? params.phoneNumber,
+      provider: "twilio",
+      sid: params.twilioAccountSid,
+      token: params.twilioAuthToken
+    };
+    const res = await this.fetchImpl(
+      `${this.baseUrl}/v1/convai/phone-numbers`,
+      {
+        method: "POST",
+        headers: this.headers({ "content-type": "application/json" }),
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(
+        `createPhoneNumberTwilio failed: ${res.status}`,
+        res.status,
+        text
+      );
+    }
+    const data = await res.json();
+    const id = data.phone_number_id ?? data.id;
+    if (!id) {
+      throw new ElevenLabsApiError(
+        "createPhoneNumberTwilio returned no id",
+        500,
+        JSON.stringify(data)
+      );
+    }
+    const patchRes = await this.fetchImpl(
+      `${this.baseUrl}/v1/convai/phone-numbers/${encodeURIComponent(id)}`,
+      {
+        method: "PATCH",
+        headers: this.headers({ "content-type": "application/json" }),
+        body: JSON.stringify({ agent_id: params.agentId })
+      }
+    );
+    if (!patchRes.ok) {
+      const text = await patchRes.text();
+      try {
+        await this.deletePhoneNumber(id);
+      } catch {
+      }
+      throw new ElevenLabsApiError(
+        `assignAgentToPhoneNumber failed: ${patchRes.status}`,
+        patchRes.status,
+        text
+      );
+    }
+    return { phoneNumberId: id };
+  }
+  /** Detach a previously-registered phone number from ElevenLabs. */
+  async deletePhoneNumber(phoneNumberId) {
+    const res = await this.fetchImpl(
+      `${this.baseUrl}/v1/convai/phone-numbers/${encodeURIComponent(phoneNumberId)}`,
+      { method: "DELETE", headers: this.headers() }
+    );
+    if (!res.ok && res.status !== 404) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(
+        `deletePhoneNumber failed: ${res.status}`,
+        res.status,
+        text
+      );
+    }
+  }
+  /**
+   * Place an outbound PSTN call via a previously-registered EL phone
+   * number. EL drives Twilio (or a SIP trunk) under the hood — we just
+   * hand it the destination number and the agent to bridge to. Returns
+   * the Twilio `callSid` + EL `conversationId` for metering / tracing.
+   *
+   * As of 2026-Q2 the EL API uses provider-scoped routes:
+   *   - Twilio numbers → POST /v1/convai/twilio/outbound-call
+   *   - SIP numbers    → POST /v1/convai/sip-trunk/outbound-call
+   * and `agent_phone_number_id` is a body field (no longer a path
+   * segment). The previous `/v1/convai/phone-numbers/{id}/outbound-call`
+   * route now returns 404. Callers that don't know the provider can
+   * look it up from `GET /v1/convai/phone-numbers/{id}` (`provider:
+   * "twilio" | "sip_trunk"`); most hosted setups are Twilio, so that's
+   * the default here.
+   */
+  async outboundCall(params) {
+    const provider = params.provider ?? "twilio";
+    const body = {
+      agent_id: params.agentId,
+      agent_phone_number_id: params.phoneNumberId,
+      to_number: params.toNumber
+    };
+    if (params.dynamicVariables) {
+      body.conversation_initiation_client_data = {
+        dynamic_variables: params.dynamicVariables
+      };
+    }
+    const res = await this.fetchImpl(
+      `${this.baseUrl}/v1/convai/${provider}/outbound-call`,
+      {
+        method: "POST",
+        headers: this.headers({ "content-type": "application/json" }),
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(
+        `outboundCall failed: ${res.status}`,
+        res.status,
+        text
+      );
+    }
+    const data = await res.json();
+    const callSid = data.call_sid ?? data.callSid;
+    const conversationId = data.conversation_id ?? data.conversationId;
+    if (!callSid || !conversationId) {
+      throw new ElevenLabsApiError(
+        "outboundCall missing callSid or conversationId",
+        500,
+        JSON.stringify(data)
+      );
+    }
+    return { callSid, conversationId };
+  }
+};
+var MEMORY_CLIENT_TOOLS = [
+  {
+    type: "client",
+    name: "add_memory",
+    description: "Save a concise canonical fact about the user (preferences, decisions, personal details, follow-ups). Use whenever the user shares something worth remembering.",
+    expects_response: true,
+    parameters: {
+      type: "object",
+      properties: {
+        fact: {
+          type: "string",
+          description: 'A short normalized fact, e.g. "prefers window seats", "favorite color: green". Max 500 chars.'
+        }
+      },
+      required: ["fact"]
+    }
+  }
+];
+
+// 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/runtime-token.ts
+var WORKSPACE_RUNTIME_TOKEN_MESSAGE = "RUNTIME_AUTH_SECRET is the workspace runtime token; app code needs its project token (rt_v1_\u2026). Start the app through the preview (server_sync / restart), not from a workspace shell.";
+function readRuntimeAuthSecret(env = typeof process === "undefined" ? void 0 : process.env) {
+  const token = env?.RUNTIME_AUTH_SECRET;
+  if (!token) return void 0;
+  if (token.startsWith("wrt_v1_")) throw new Error(WORKSPACE_RUNTIME_TOKEN_MESSAGE);
+  return token;
+}
+
+export {
+  DEFAULT_MEMORY_BLOCK,
+  stripMemoryBlock,
+  extractBasePrompt,
+  composeAgentPrompt,
+  DEFAULT_ELEVENLABS_BASE_URL,
+  VOICE_TTS_MODELS,
+  VOICE_TTS_MODEL_IDS,
+  DEFAULT_TTS_MODEL,
+  CONVAI_SUPPORTED_TTS_MODELS,
+  CONVAI_TTS_MODEL_FALLBACK,
+  TTS_FALLBACK_MODEL,
+  getVoiceTtsModel,
+  resolveConvaiTtsModelDetailed,
+  resolveConvaiTtsModel,
+  isModelRelatedTtsFailure,
+  DEFAULT_MUSIC_MODEL,
+  VOICE_STS_MODEL_IDS,
+  DEFAULT_STS_MODEL,
+  VOICE_SPEECH_TO_TEXT_MODEL_IDS,
+  DEFAULT_SPEECH_TO_TEXT_MODEL,
+  VOICE_SOUND_GENERATION_MODEL_IDS,
+  DEFAULT_SOUND_GENERATION_MODEL,
+  ElevenLabsApiError,
+  ElevenLabsClient,
+  MEMORY_CLIENT_TOOLS,
+  VOICE_OPS,
+  VOICE_OP_IDS,
+  getVoiceOp,
+  voiceOpForwardPath,
+  voiceOpIsMultipart,
+  voiceOpReturnsAudio,
+  voiceOpUpstreamPath,
+  voiceOpCredentialError,
+  parseVoiceOpJsonBody,
+  parseVoiceOpForm,
+  voiceOpUpstreamBody,
+  voiceOpPathParams,
+  WORKSPACE_RUNTIME_TOKEN_MESSAGE,
+  readRuntimeAuthSecret
+};
+//# sourceMappingURL=chunk-IOFWML5L.js.map