@shogo-ai/voice 1.4.1

package/dist/route/audio-tags.cjs

@@ -0,0 +1,975 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/route/audio-tags.ts
+var audio_tags_exports = {};
+__export(audio_tags_exports, {
+  GET: () => GET
+});
+module.exports = __toCommonJS(audio_tags_exports);
+
+// src/audioTags.ts
+var AUDIO_TAGS = [
+  // Emotions
+  { tag: "happy", group: "emotion", label: "Happy", description: "Warm, upbeat delivery.", example: "[happy] Oh, I\u2019m so glad you stopped by." },
+  { tag: "sad", group: "emotion", label: "Sad", description: "Subdued, heavy-hearted tone.", example: "[sad] I wish things had gone differently." },
+  { tag: "excited", group: "emotion", label: "Excited", description: "Energized, eager delivery.", example: "[excited] Wait until you hear this!" },
+  { tag: "curious", group: "emotion", label: "Curious", description: "Inquisitive, rising inflection.", example: "[curious] Hmm, what did they look like?" },
+  { tag: "sarcastic", group: "emotion", label: "Sarcastic", description: "Dry, ironic tone.", example: "[sarcastic] Oh, fantastic. Another Monday." },
+  { tag: "angry", group: "emotion", label: "Angry", description: "Sharp, irritated edge.", example: "[angry] I told you not to touch that." },
+  { tag: "nervous", group: "emotion", label: "Nervous", description: "Uneasy, faltering delivery.", example: "[nervous] I\u2014 I didn\u2019t think you\u2019d actually come." },
+  { tag: "confident", group: "emotion", label: "Confident", description: "Grounded, assured delivery.", example: "[confident] Trust me. I\u2019ve done this before." },
+  // Delivery
+  { tag: "whispers", group: "delivery", label: "Whispers", description: "Hushed, close-mic delivery.", example: "[whispers] Don\u2019t say it too loud." },
+  { tag: "shouts", group: "delivery", label: "Shouts", description: "Loud, projected delivery.", example: "[shouts] Look out behind you!" },
+  { tag: "softly", group: "delivery", label: "Softly", description: "Gentle, quiet tone.", example: "[softly] It\u2019s okay. I\u2019m here." },
+  { tag: "slowly", group: "delivery", label: "Slowly", description: "Deliberate pacing.", example: "[slowly] Tell me\u2026 exactly\u2026 what happened." },
+  { tag: "quickly", group: "delivery", label: "Quickly", description: "Rapid, urgent pacing.", example: "[quickly] We need to go, right now." },
+  // Reactions (non-verbal sounds)
+  { tag: "laughs", group: "reaction", label: "Laughs", description: "A genuine laugh.", example: "That\u2019s ridiculous [laughs]." },
+  { tag: "chuckles", group: "reaction", label: "Chuckles", description: "A small, warm chuckle.", example: "[chuckles] You always say that." },
+  { tag: "sighs", group: "reaction", label: "Sighs", description: "An audible sigh.", example: "[sighs] Alright, fine. Let\u2019s do it." },
+  { tag: "gasps", group: "reaction", label: "Gasps", description: "A sharp inhale of surprise.", example: "[gasps] You didn\u2019t!" },
+  { tag: "hesitates", group: "reaction", label: "Hesitates", description: "A pause with uncertainty.", example: "[hesitates] I\u2019m not sure I should say." },
+  { tag: "clears throat", group: "reaction", label: "Clears throat", description: "Throat-clearing beat.", example: "[clears throat] As I was saying\u2026" }
+];
+var AUDIO_TAG_GROUPS = [
+  { id: "emotion", label: "Emotions", description: "Overall feeling carried through the line." },
+  { id: "delivery", label: "Delivery", description: "How the words are spoken (pace, volume)." },
+  { id: "reaction", label: "Reactions", description: "Non-verbal sounds mixed into speech." }
+];
+var EXPRESSIVITY_OPTIONS = [
+  { id: "off", label: "Off", description: "No audio tags. Plain, natural delivery." },
+  { id: "subtle", label: "Subtle", description: "Occasional tag when it genuinely fits. Default." },
+  { id: "full", label: "Full", description: "Freely expressive \u2014 tags sprinkled to carry emotion and reactions." }
+];
+var DEFAULT_ALLOWED_TAGS = [
+  "whispers",
+  "laughs",
+  "sighs",
+  "excited",
+  "curious",
+  "softly"
+];
+var DEFAULT_VOICE_SETTINGS = {
+  stability: 0.5,
+  similarity_boost: 0.8,
+  style: 0,
+  use_speaker_boost: true
+};
+var KNOWN_TAG_SET = new Set(AUDIO_TAGS.map((t) => t.tag.toLowerCase()));
+var EXPRESSIVITY_BLOCK_OPEN = "<!--expressivity-->";
+var EXPRESSIVITY_BLOCK_CLOSE = "<!--/expressivity-->";
+function stripExpressivityBlock(prompt) {
+  if (!prompt) return prompt;
+  const open = EXPRESSIVITY_BLOCK_OPEN;
+  const close = EXPRESSIVITY_BLOCK_CLOSE;
+  const openIdx = prompt.indexOf(open);
+  if (openIdx === -1) return prompt;
+  const closeIdx = prompt.indexOf(close, openIdx);
+  if (closeIdx === -1) return prompt;
+  const before = prompt.slice(0, openIdx).replace(/\s+$/, "");
+  const after = prompt.slice(closeIdx + close.length).replace(/^\s+/, "");
+  return [before, after].filter(Boolean).join("\n\n");
+}
+function composeExpressivityBlock(expressivity, allowedTags) {
+  if (expressivity === "off") return "";
+  const allowed = (allowedTags && allowedTags.length > 0 ? allowedTags : DEFAULT_ALLOWED_TAGS).filter((t) => AUDIO_TAGS.some((a) => a.tag === t));
+  if (allowed.length === 0) return "";
+  const intensity = expressivity === "full" ? "Use audio tags liberally to color your speech with emotion, delivery, and non-verbal reactions. Most substantive replies should include at least one tag. Never add so many tags that a line becomes unnatural." : "Use audio tags sparingly \u2014 only when one genuinely fits the emotion or reaction of the moment. Most lines will have no tag. At most one or two tags per reply.";
+  const tagList = allowed.map((t) => {
+    const entry = AUDIO_TAGS.find((a) => a.tag === t);
+    return `  - [${entry.tag}] \u2014 ${entry.description} Example: ${entry.example}`;
+  }).join("\n");
+  const body = [
+    "You speak through an expressive TTS engine that understands inline audio tags.",
+    'Audio tags are lowercase words in square brackets placed directly in your spoken text \u2014 e.g. "[whispers] don\u2019t tell anyone" or "that was wild [laughs]".',
+    'Tags are performance cues, not words. Never describe a tag (do not say "asterisk laughs asterisk" or "*laughs*"). Never read a tag aloud. Never put tags inside quoted speech from another character.',
+    intensity,
+    "You may only use tags from this allow-list:",
+    tagList,
+    "If no tag fits, use none. Tags are optional flavor, not filler."
+  ].join("\n");
+  return `${EXPRESSIVITY_BLOCK_OPEN}
+${body}
+${EXPRESSIVITY_BLOCK_CLOSE}`;
+}
+function buildPreviewLine(allowedTags, characterName = "your companion") {
+  const tags = (allowedTags ?? []).filter((t) => AUDIO_TAGS.some((a) => a.tag === t));
+  if (tags.length === 0) {
+    return `Hi there. This is a quick preview of how ${characterName} sounds.`;
+  }
+  const pick = tags.slice(0, 3);
+  const lead = pick[0];
+  const mid = pick[1];
+  const tail = pick[2];
+  if (pick.length === 1) {
+    return `[${lead}] Hey \u2014 this is how ${characterName} sounds when the mood takes over.`;
+  }
+  if (pick.length === 2) {
+    return `[${lead}] Oh, this is fun. [${mid}] Let me know what you think.`;
+  }
+  return `[${lead}] Okay, listen. [${mid}] This is the new voice. [${tail}] How does it feel?`;
+}
+function normalizeAudioTags(raw) {
+  if (!Array.isArray(raw)) return null;
+  const cleaned = raw.filter((x) => typeof x === "string").map((x) => x.trim().toLowerCase()).filter((x) => AUDIO_TAGS.some((a) => a.tag === x));
+  return Array.from(new Set(cleaned));
+}
+function normalizeExpressivity(raw) {
+  if (raw === "off" || raw === "subtle" || raw === "full") return raw;
+  return void 0;
+}
+function normalizeVoiceSettings(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const src = raw;
+  const out = {};
+  const clamp = (v) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : void 0;
+  const stability = clamp(src.stability);
+  const similarity = clamp(src.similarity_boost ?? src.similarityBoost);
+  const style = clamp(src.style);
+  const boost = src.use_speaker_boost ?? src.useSpeakerBoost;
+  if (stability !== void 0) out.stability = stability;
+  if (similarity !== void 0) out.similarity_boost = similarity;
+  if (style !== void 0) out.style = style;
+  if (typeof boost === "boolean") out.use_speaker_boost = boost;
+  return Object.keys(out).length ? out : void 0;
+}
+function readAudioTags(raw) {
+  const norm = normalizeAudioTags(raw);
+  return norm && norm.length > 0 ? norm : DEFAULT_ALLOWED_TAGS;
+}
+function readExpressivity(raw) {
+  return normalizeExpressivity(raw) ?? "subtle";
+}
+function readVoiceSettings(raw) {
+  return normalizeVoiceSettings(raw) ?? { ...DEFAULT_VOICE_SETTINGS };
+}
+
+// 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 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";
+function resolveConvaiTtsModel(requested) {
+  if (requested && CONVAI_SUPPORTED_TTS_MODELS.has(requested)) return requested;
+  return CONVAI_TTS_MODEL_FALLBACK;
+}
+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 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).
+   */
+  async textToSpeech(params) {
+    const modelId = params.modelId && params.modelId.length > 0 ? params.modelId : "eleven_v3";
+    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(modelId);
+    let used = modelId;
+    if (!res.ok && modelId !== "eleven_turbo_v2_5") {
+      res = await attempt("eleven_turbo_v2_5");
+      used = "eleven_turbo_v2_5";
+    }
+    if (!res.ok) {
+      const text = await res.text();
+      throw new ElevenLabsApiError(`textToSpeech failed: ${res.status}`, res.status, text);
+    }
+    const audio = await res.arrayBuffer();
+    const contentType = res.headers.get("content-type") ?? accept;
+    return { audio, modelId: used, contentType };
+  }
+  /** 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/server.ts
+function json(data, status = 200, extraHeaders = {}) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...extraHeaders }
+  });
+}
+async function readJson(req) {
+  try {
+    const text = await req.text();
+    if (!text) return {};
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+var NOOP_LOGGER = () => {
+};
+function resolveProxyOptions(config) {
+  if (config.proxy) {
+    if (!config.proxy.runtimeToken || !config.proxy.projectId || !config.proxy.apiUrl) {
+      throw new Error(
+        "createVoiceHandlers: proxy requires runtimeToken, projectId, and apiUrl"
+      );
+    }
+    return config.proxy;
+  }
+  if (typeof process === "undefined" || !process.env) return null;
+  const runtimeToken = process.env.RUNTIME_AUTH_SECRET;
+  const projectId = process.env.PROJECT_ID;
+  if (!runtimeToken || !projectId) return null;
+  const apiUrl = process.env.SHOGO_API_URL ?? process.env.SHOGO_CLOUD_URL ?? "http://localhost:8002";
+  return {
+    runtimeToken,
+    projectId,
+    apiUrl,
+    ...config.fetch ? { fetch: config.fetch } : {}
+  };
+}
+function createProxyHandlers(proxy, log) {
+  const fetchImpl = proxy.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "createVoiceHandlers proxy: global fetch is unavailable; pass proxy.fetch"
+    );
+  }
+  const apiBase = proxy.apiUrl.replace(/\/+$/, "");
+  function proxyUrl(path, forward) {
+    const tail = [`projectId=${encodeURIComponent(proxy.projectId)}`];
+    for (const [k, v] of Object.entries(forward)) {
+      if (typeof v === "string" && v.length > 0) {
+        tail.push(`${k}=${encodeURIComponent(v)}`);
+      }
+    }
+    const sep = path.includes("?") ? "&" : "?";
+    return `${apiBase}${path}${sep}${tail.join("&")}`;
+  }
+  const FORWARDED_SIGNED_URL_PARAMS = ["agentName"];
+  async function doSignedUrl(req) {
+    if (req.method !== "GET") return json({ error: "Method Not Allowed" }, 405);
+    try {
+      let incomingUrl = null;
+      try {
+        incomingUrl = new URL(req.url);
+      } catch {
+      }
+      const forward = {};
+      if (incomingUrl) {
+        for (const key of FORWARDED_SIGNED_URL_PARAMS) {
+          const v = incomingUrl.searchParams.get(key);
+          if (v != null) forward[key] = v;
+        }
+      }
+      const upstream = await fetchImpl(proxyUrl("/api/voice/signed-url", forward), {
+        method: "GET",
+        headers: { "x-runtime-token": proxy.runtimeToken },
+        credentials: "omit"
+      });
+      const body = await upstream.text();
+      const headers = { "content-type": "application/json" };
+      const ct = upstream.headers.get("content-type");
+      if (ct) headers["content-type"] = ct;
+      return new Response(body, { status: upstream.status, headers });
+    } catch (err) {
+      log("error", "proxy signedUrl failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return json({ error: "signedUrl proxy failed" }, 502);
+    }
+  }
+  async function doAudioTags(req) {
+    if (req.method !== "GET") return json({ error: "Method Not Allowed" }, 405);
+    return json({
+      tags: AUDIO_TAGS,
+      groups: AUDIO_TAG_GROUPS,
+      expressivity: EXPRESSIVITY_OPTIONS,
+      defaults: {
+        allowedTags: DEFAULT_ALLOWED_TAGS,
+        voiceSettings: DEFAULT_VOICE_SETTINGS,
+        ttsModelId: CONVAI_TTS_MODEL_FALLBACK
+      }
+    });
+  }
+  function notImplemented(label) {
+    return async () => json(
+      {
+        error: "Not Implemented",
+        detail: `${label} is not available in runtime-token proxy mode; use BYO-EL or the hosted bearer SDK path.`
+      },
+      501
+    );
+  }
+  return {
+    signedUrl: doSignedUrl,
+    tts: notImplemented("tts"),
+    agent: {
+      create: notImplemented("agent.create"),
+      patch: notImplemented("agent.patch"),
+      delete: notImplemented("agent.delete")
+    },
+    audioTags: doAudioTags,
+    // In proxy mode we don't own an EL client. Expose a throwing stub so
+    // accidental use is loud instead of silently passing around a
+    // half-configured client.
+    elevenLabs: new Proxy({}, {
+      get(_t, prop) {
+        throw new Error(
+          `createVoiceHandlers: elevenLabs.${String(prop)} is not available in runtime-token proxy mode`
+        );
+      }
+    })
+  };
+}
+function createVoiceHandlers(config) {
+  const log = config.logger ?? NOOP_LOGGER;
+  const proxy = resolveProxyOptions(config);
+  if (proxy) {
+    if (config.apiKey) {
+      log("warn", "createVoiceHandlers: apiKey provided but runtime-token proxy mode is active; apiKey is ignored");
+    }
+    return createProxyHandlers(proxy, log);
+  }
+  if (!config.apiKey) throw new Error("createVoiceHandlers: apiKey is required");
+  if (!config.getUser) throw new Error("createVoiceHandlers: getUser is required");
+  if (!config.companionStore) throw new Error("createVoiceHandlers: companionStore is required");
+  const getUser = config.getUser;
+  const companionStore = config.companionStore;
+  const includeMemoryTools = config.includeMemoryTools ?? true;
+  const tools = includeMemoryTools ? MEMORY_CLIENT_TOOLS : void 0;
+  const elConfig = {
+    apiKey: config.apiKey,
+    ...config.elevenLabsBaseUrl ? { baseUrl: config.elevenLabsBaseUrl } : {},
+    ...config.fetch ? { fetch: config.fetch } : {}
+  };
+  const el = new ElevenLabsClient(elConfig);
+  async function resolveUser(req) {
+    const u = await getUser(req);
+    if (!u) return json({ error: "Unauthorized" }, 401);
+    return u;
+  }
+  function handleElError(e, fallbackLabel) {
+    if (e instanceof ElevenLabsApiError) {
+      log("warn", `${fallbackLabel}: 11Labs ${e.status}`, { body: e.body });
+      return json({ error: fallbackLabel, detail: e.body }, 502);
+    }
+    const message = e instanceof Error ? e.message : String(e);
+    log("error", `${fallbackLabel}: ${message}`);
+    return json({ error: fallbackLabel, detail: message }, 500);
+  }
+  async function doSignedUrl(req) {
+    if (req.method !== "GET") return json({ error: "Method Not Allowed" }, 405);
+    const u = await resolveUser(req);
+    if (u instanceof Response) return u;
+    const companion = await companionStore.findByUserId(u.id);
+    if (!companion || !companion.agentId) return json({ error: "No companion" }, 404);
+    const basePrompt = extractBasePrompt(companion.systemPrompt || "");
+    try {
+      await el.patchAgent(companion.agentId, {
+        systemPrompt: basePrompt,
+        tools,
+        enableUserContextOverride: includeMemoryTools,
+        voiceId: companion.voiceId,
+        expressivity: readExpressivity(companion.expressivity),
+        audioTags: readAudioTags(companion.audioTags),
+        voiceSettings: readVoiceSettings(companion.voiceSettings),
+        ttsModelId: companion.ttsModelId ?? null,
+        ...includeMemoryTools ? {} : { memoryBlock: null }
+      });
+      if (basePrompt !== companion.systemPrompt) {
+        await companionStore.update(u.id, { systemPrompt: basePrompt });
+      }
+    } catch (e) {
+      log("warn", "signedUrl: pre-sync patch failed; continuing", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+    let signedUrl;
+    try {
+      signedUrl = await el.getSignedUrl(companion.agentId);
+    } catch (e) {
+      return handleElError(e, "Failed to get signed url");
+    }
+    let userContext = "";
+    if (config.memoryStore) {
+      try {
+        const store = config.memoryStore(u.id);
+        const hits = store.search(companion.characterName || "recent context", { limit: 5 });
+        if (hits.length) {
+          userContext = hits.map(
+            (h) => `- ${h.matchType ? `[${h.matchType}] ` : ""}${h.chunk.trim().replace(/\s+/g, " ").slice(0, 220)}`
+          ).join("\n");
+        }
+      } catch (e) {
+        log("warn", "signedUrl: memory preload failed", {
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+    return json({ signedUrl, agentId: companion.agentId, userContext });
+  }
+  async function doTts(req) {
+    if (req.method !== "POST") return json({ error: "Method Not Allowed" }, 405);
+    const u = await resolveUser(req);
+    if (u instanceof Response) return u;
+    const raw = await readJson(req);
+    if (raw === null || typeof raw !== "object") return json({ error: "Invalid JSON body" }, 400);
+    const body = raw;
+    const voiceId = typeof body.voiceId === "string" ? body.voiceId.trim() : "";
+    if (!voiceId) return json({ error: "Missing voiceId" }, 400);
+    const voiceSettings = normalizeVoiceSettings(body.voiceSettings) ?? { stability: 0.5, similarity_boost: 0.8, style: 0 };
+    let text;
+    if (typeof body.text === "string" && body.text.trim().length > 0) {
+      text = body.text.slice(0, 400);
+    } else {
+      const tags = normalizeAudioTags(body.audioTags) ?? [];
+      text = buildPreviewLine(tags, body.characterName ?? "your companion").slice(0, 400);
+    }
+    try {
+      const { audio, modelId, contentType } = await el.textToSpeech({
+        voiceId,
+        text,
+        ...body.modelId ? { modelId: body.modelId } : {},
+        voiceSettings
+      });
+      return new Response(audio, {
+        headers: {
+          "content-type": contentType,
+          "cache-control": "private, max-age=3600",
+          "x-tts-model-used": modelId
+        }
+      });
+    } catch (e) {
+      return handleElError(e, "TTS failed");
+    }
+  }
+  async function doAgentCreate(req) {
+    if (req.method !== "POST") return json({ error: "Method Not Allowed" }, 405);
+    const u = await resolveUser(req);
+    if (u instanceof Response) return u;
+    const existing = await companionStore.findByUserId(u.id);
+    if (existing) return json({ error: "Companion already exists" }, 409);
+    const raw = await readJson(req);
+    if (raw === null || typeof raw !== "object") return json({ error: "Invalid JSON body" }, 400);
+    const body = raw;
+    if (typeof body.displayName !== "string" || typeof body.characterName !== "string" || typeof body.voiceId !== "string" || typeof body.systemPrompt !== "string" || typeof body.firstMessage !== "string") {
+      return json({ error: "Missing required fields" }, 400);
+    }
+    const expressivity = readExpressivity(body.expressivity);
+    const audioTags = readAudioTags(body.audioTags);
+    const voiceSettings = readVoiceSettings(body.voiceSettings);
+    const ttsModelId = resolveConvaiTtsModel(body.ttsModelId);
+    let agentId;
+    try {
+      agentId = await el.createAgent({
+        displayName: body.displayName,
+        characterName: body.characterName,
+        voiceId: body.voiceId,
+        systemPrompt: body.systemPrompt,
+        firstMessage: body.firstMessage,
+        expressivity,
+        audioTags,
+        voiceSettings,
+        ttsModelId,
+        ...tools ? { tools } : {},
+        ...includeMemoryTools ? {} : { memoryBlock: null }
+      });
+    } catch (e) {
+      return handleElError(e, "Failed to create agent");
+    }
+    const cleanedPrompt = extractBasePrompt(body.systemPrompt);
+    const companion = await companionStore.create({
+      userId: u.id,
+      agentId,
+      displayName: body.displayName,
+      characterName: body.characterName,
+      voiceId: body.voiceId,
+      systemPrompt: cleanedPrompt,
+      firstMessage: body.firstMessage,
+      expressivity,
+      audioTags,
+      voiceSettings,
+      ttsModelId
+    });
+    return json(companion);
+  }
+  async function doAgentPatch(req) {
+    if (req.method !== "PATCH") return json({ error: "Method Not Allowed" }, 405);
+    const u = await resolveUser(req);
+    if (u instanceof Response) return u;
+    const existing = await companionStore.findByUserId(u.id);
+    if (!existing) return json({ error: "No companion" }, 404);
+    const raw = await readJson(req);
+    if (raw === null || typeof raw !== "object") return json({ error: "Invalid JSON body" }, 400);
+    const body = raw;
+    const patch = {};
+    if (body.displayName !== void 0) patch.displayName = body.displayName;
+    if (body.characterName !== void 0) patch.characterName = body.characterName;
+    if (body.voiceId !== void 0) patch.voiceId = body.voiceId;
+    if (body.firstMessage !== void 0) patch.firstMessage = body.firstMessage;
+    const expressivity = normalizeExpressivity(body.expressivity);
+    if (expressivity !== void 0) patch.expressivity = expressivity;
+    let audioTagsPatch;
+    if (body.audioTags !== void 0) {
+      audioTagsPatch = normalizeAudioTags(body.audioTags) ?? [];
+      patch.audioTags = audioTagsPatch;
+    }
+    if (body.voiceSettings !== void 0) {
+      const vs = normalizeVoiceSettings(body.voiceSettings);
+      patch.voiceSettings = vs ?? null;
+    }
+    if (body.ttsModelId !== void 0) patch.ttsModelId = body.ttsModelId ?? null;
+    const cleanedPrompt = body.systemPrompt !== void 0 ? extractBasePrompt(body.systemPrompt) : void 0;
+    if (cleanedPrompt !== void 0) patch.systemPrompt = cleanedPrompt;
+    const needs11Labs = body.displayName !== void 0 || body.characterName !== void 0 || body.voiceId !== void 0 || body.systemPrompt !== void 0 || body.firstMessage !== void 0 || body.expressivity !== void 0 || body.audioTags !== void 0 || body.voiceSettings !== void 0 || body.ttsModelId !== void 0;
+    if (existing.agentId && needs11Labs) {
+      const finalExpressivity = patch.expressivity ?? readExpressivity(existing.expressivity);
+      const finalTags = audioTagsPatch !== void 0 ? audioTagsPatch : readAudioTags(existing.audioTags);
+      const finalVoiceSettings = body.voiceSettings !== void 0 ? normalizeVoiceSettings(body.voiceSettings) ?? void 0 : readVoiceSettings(existing.voiceSettings);
+      const finalTtsModelId = body.ttsModelId !== void 0 ? body.ttsModelId ?? null : existing.ttsModelId ?? null;
+      try {
+        await el.patchAgent(existing.agentId, {
+          ...body.displayName !== void 0 ? { displayName: body.displayName } : {},
+          ...body.characterName !== void 0 ? { characterName: body.characterName } : {},
+          ...body.voiceId !== void 0 ? { voiceId: body.voiceId } : {},
+          systemPrompt: cleanedPrompt !== void 0 ? cleanedPrompt : body.expressivity !== void 0 || body.audioTags !== void 0 ? existing.systemPrompt : void 0,
+          ...body.firstMessage !== void 0 ? { firstMessage: body.firstMessage } : {},
+          expressivity: finalExpressivity,
+          audioTags: finalTags,
+          ...finalVoiceSettings ? { voiceSettings: finalVoiceSettings } : {},
+          ttsModelId: finalTtsModelId,
+          ...includeMemoryTools ? {} : { memoryBlock: null }
+        });
+      } catch (e) {
+        return handleElError(e, "Failed to patch agent");
+      }
+    }
+    const companion = await companionStore.update(u.id, patch);
+    return json(companion);
+  }
+  async function doAgentDelete(req) {
+    if (req.method !== "DELETE") return json({ error: "Method Not Allowed" }, 405);
+    const u = await resolveUser(req);
+    if (u instanceof Response) return u;
+    const existing = await companionStore.findByUserId(u.id);
+    if (!existing) return json({ ok: true });
+    if (existing.agentId) await el.deleteAgent(existing.agentId);
+    await companionStore.delete(u.id);
+    return json({ ok: true });
+  }
+  async function doAudioTags(req) {
+    if (req.method !== "GET") return json({ error: "Method Not Allowed" }, 405);
+    return json({
+      tags: AUDIO_TAGS,
+      groups: AUDIO_TAG_GROUPS,
+      expressivity: EXPRESSIVITY_OPTIONS,
+      defaults: {
+        allowedTags: DEFAULT_ALLOWED_TAGS,
+        voiceSettings: DEFAULT_VOICE_SETTINGS,
+        ttsModelId: CONVAI_TTS_MODEL_FALLBACK
+      }
+    });
+  }
+  return {
+    signedUrl: doSignedUrl,
+    tts: doTts,
+    agent: {
+      create: doAgentCreate,
+      patch: doAgentPatch,
+      delete: doAgentDelete
+    },
+    audioTags: doAudioTags,
+    elevenLabs: el
+  };
+}
+
+// src/route/index.ts
+function defaultHandlers() {
+  return createVoiceHandlers({});
+}
+
+// src/route/audio-tags.ts
+var GET = (req) => defaultHandlers().audioTags(req);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GET
+});
+//# sourceMappingURL=audio-tags.cjs.map