@shogo-ai/voice 1.4.1

package/dist/index.cjs

@@ -0,0 +1,1316 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUDIO_TAGS: () => AUDIO_TAGS,
+  AUDIO_TAG_GROUPS: () => AUDIO_TAG_GROUPS,
+  CONVAI_SUPPORTED_TTS_MODELS: () => CONVAI_SUPPORTED_TTS_MODELS,
+  CONVAI_TTS_MODEL_FALLBACK: () => CONVAI_TTS_MODEL_FALLBACK,
+  DEFAULT_ALLOWED_TAGS: () => DEFAULT_ALLOWED_TAGS,
+  DEFAULT_ELEVENLABS_BASE_URL: () => DEFAULT_ELEVENLABS_BASE_URL,
+  DEFAULT_MEMORY_BLOCK: () => DEFAULT_MEMORY_BLOCK,
+  DEFAULT_TWILIO_BASE_URL: () => DEFAULT_TWILIO_BASE_URL,
+  DEFAULT_VOICE_SETTINGS: () => DEFAULT_VOICE_SETTINGS,
+  DirectTelephonyClient: () => DirectTelephonyClient,
+  EXPRESSIVITY_BLOCK_CLOSE: () => EXPRESSIVITY_BLOCK_CLOSE,
+  EXPRESSIVITY_BLOCK_OPEN: () => EXPRESSIVITY_BLOCK_OPEN,
+  EXPRESSIVITY_OPTIONS: () => EXPRESSIVITY_OPTIONS,
+  ElevenLabsApiError: () => ElevenLabsApiError,
+  ElevenLabsClient: () => ElevenLabsClient,
+  HostedRuntimeTokenClient: () => HostedRuntimeTokenClient,
+  HostedTelephonyClient: () => HostedTelephonyClient,
+  MEMORY_CLIENT_TOOLS: () => MEMORY_CLIENT_TOOLS,
+  MockTelephonyClient: () => MockTelephonyClient,
+  TelephonyApiError: () => TelephonyApiError,
+  TelephonyConfigError: () => TelephonyConfigError,
+  TwilioApiError: () => TwilioApiError,
+  TwilioClient: () => TwilioClient,
+  buildPreviewLine: () => buildPreviewLine,
+  composeAgentPrompt: () => composeAgentPrompt,
+  composeExpressivityBlock: () => composeExpressivityBlock,
+  createTelephonyClient: () => createTelephonyClient,
+  extractBasePrompt: () => extractBasePrompt,
+  isVoiceMockEnv: () => isVoiceMockEnv,
+  normalizeAudioTags: () => normalizeAudioTags,
+  normalizeExpressivity: () => normalizeExpressivity,
+  normalizeVoiceSettings: () => normalizeVoiceSettings,
+  readAudioTags: () => readAudioTags,
+  readExpressivity: () => readExpressivity,
+  readVoiceSettings: () => readVoiceSettings,
+  resolveConvaiTtsModel: () => resolveConvaiTtsModel,
+  stripAudioTags: () => stripAudioTags,
+  stripExpressivityBlock: () => stripExpressivityBlock,
+  stripMemoryBlock: () => stripMemoryBlock
+});
+module.exports = __toCommonJS(index_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()));
+function stripAudioTags(text) {
+  if (!text) return "";
+  return text.replace(/\[([a-z][a-z ]{0,24})\]/gi, (match, inner) => {
+    const key = inner.trim().toLowerCase();
+    return KNOWN_TAG_SET.has(key) ? "" : match;
+  }).replace(/[ \t]{2,}/g, " ").replace(/\s+([,.!?;:])/g, "$1").trim();
+}
+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/twilio.ts
+var DEFAULT_TWILIO_BASE_URL = "https://api.twilio.com";
+var TwilioApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "TwilioApiError";
+  }
+};
+function toBase64(s) {
+  if (typeof btoa === "function") return btoa(s);
+  const nodeBuffer = globalThis.Buffer;
+  if (nodeBuffer) return nodeBuffer.from(s, "utf-8").toString("base64");
+  throw new Error("twilio.ts: no base64 encoder available in this runtime");
+}
+var TwilioClient = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.accountSid) throw new Error("TwilioClient: accountSid is required");
+    if (!config.authToken) throw new Error("TwilioClient: authToken is required");
+    this.baseUrl = (config.baseUrl ?? DEFAULT_TWILIO_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = config.fetch ?? globalThis.fetch;
+    if (typeof this.fetchImpl !== "function") {
+      throw new Error("TwilioClient: global fetch is unavailable; pass config.fetch");
+    }
+    this.basicAuth = `Basic ${toBase64(`${config.accountSid}:${config.authToken}`)}`;
+  }
+  accountUrl(path) {
+    return `${this.baseUrl}/2010-04-01/Accounts/${encodeURIComponent(
+      this.config.accountSid
+    )}${path}`;
+  }
+  headers(extra = {}) {
+    return { authorization: this.basicAuth, ...extra };
+  }
+  async searchAvailable(params = {}) {
+    const country = (params.country ?? "US").toUpperCase();
+    const search = new URLSearchParams();
+    if (params.areaCode) search.set("AreaCode", params.areaCode);
+    if (params.contains) search.set("Contains", params.contains);
+    search.set("PageSize", String(params.limit ?? 10));
+    const url = `${this.accountUrl(
+      `/AvailablePhoneNumbers/${country}/Local.json`
+    )}?${search.toString()}`;
+    const res = await this.fetchImpl(url, { headers: this.headers() });
+    if (!res.ok) {
+      throw new TwilioApiError(
+        `searchAvailable failed: ${res.status}`,
+        res.status,
+        await res.text()
+      );
+    }
+    const data = await res.json();
+    return (data.available_phone_numbers ?? []).map((n) => ({
+      phoneNumber: n.phone_number,
+      friendlyName: n.friendly_name ?? n.phone_number,
+      region: n.region,
+      locality: n.locality,
+      isoCountry: n.iso_country
+    }));
+  }
+  async purchaseNumber(params) {
+    const body = new URLSearchParams();
+    body.set("PhoneNumber", params.phoneNumber);
+    if (params.friendlyName) body.set("FriendlyName", params.friendlyName);
+    if (params.voiceUrl) body.set("VoiceUrl", params.voiceUrl);
+    const res = await this.fetchImpl(this.accountUrl("/IncomingPhoneNumbers.json"), {
+      method: "POST",
+      headers: this.headers({ "content-type": "application/x-www-form-urlencoded" }),
+      body: body.toString()
+    });
+    if (!res.ok) {
+      throw new TwilioApiError(
+        `purchaseNumber failed: ${res.status}`,
+        res.status,
+        await res.text()
+      );
+    }
+    const data = await res.json();
+    return {
+      sid: data.sid,
+      phoneNumber: data.phone_number,
+      friendlyName: data.friendly_name ?? data.phone_number,
+      voiceUrl: data.voice_url
+    };
+  }
+  async releaseNumber(sid) {
+    const res = await this.fetchImpl(
+      this.accountUrl(`/IncomingPhoneNumbers/${encodeURIComponent(sid)}.json`),
+      { method: "DELETE", headers: this.headers() }
+    );
+    if (!res.ok && res.status !== 404) {
+      throw new TwilioApiError(
+        `releaseNumber failed: ${res.status}`,
+        res.status,
+        await res.text()
+      );
+    }
+  }
+};
+
+// src/telephony.ts
+var TelephonyConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TelephonyConfigError";
+  }
+};
+var TelephonyApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "TelephonyApiError";
+  }
+};
+var HostedTelephonyClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.mode = "hosted";
+    if (!opts.shogoApiKey) {
+      throw new TelephonyConfigError("Hosted telephony requires shogoApiKey");
+    }
+    if (!opts.projectId) {
+      throw new TelephonyConfigError("Hosted telephony requires projectId");
+    }
+    if (!opts.apiUrl) {
+      throw new TelephonyConfigError("Hosted telephony requires apiUrl");
+    }
+    this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (typeof this.fetchImpl !== "function") {
+      throw new TelephonyConfigError("global fetch is unavailable; pass opts.fetch");
+    }
+  }
+  url(path) {
+    return `${this.opts.apiUrl.replace(/\/+$/, "")}${path}`;
+  }
+  async request(path, init = {}) {
+    const headers = {
+      authorization: `Bearer ${this.opts.shogoApiKey}`,
+      ...init.headers
+    };
+    let body = init.body;
+    if (init.json !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(init.json);
+    }
+    const res = await this.fetchImpl(this.url(path), {
+      ...init,
+      headers,
+      body,
+      credentials: "omit"
+    });
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      const message = parsed?.error ?? parsed?.message ?? `Shogo API error: ${res.status}`;
+      throw new TelephonyApiError(message, res.status, parsed);
+    }
+    return parsed;
+  }
+  async provisionNumber(opts = {}) {
+    const data = await this.request(
+      `/api/voice/twilio/provision-number/${encodeURIComponent(
+        this.opts.projectId
+      )}`,
+      {
+        method: "POST",
+        json: {
+          areaCode: opts.areaCode,
+          country: opts.country,
+          friendlyName: opts.friendlyName
+        }
+      }
+    );
+    return {
+      phoneNumber: data.phoneNumber,
+      twilioPhoneSid: data.twilioPhoneSid,
+      elevenlabsPhoneId: data.elevenlabsPhoneId,
+      setupBilledUsd: data.setupBilledUsd,
+      monthlyBilledUsd: data.monthlyBilledUsd,
+      usageDebited: data.usageDebited
+    };
+  }
+  async outboundCall(opts) {
+    const data = await this.request(
+      `/api/voice/twilio/outbound/${encodeURIComponent(this.opts.projectId)}`,
+      {
+        method: "POST",
+        json: { to: opts.to, dynamicVariables: opts.dynamicVariables }
+      }
+    );
+    return {
+      callSid: data.callSid,
+      conversationId: data.conversationId,
+      estimatedBilledUsd: data.estimatedBilledUsd,
+      billedUsdPerMinute: data.billedUsdPerMinute
+    };
+  }
+  async releaseNumber() {
+    await this.request(
+      `/api/voice/twilio/number/${encodeURIComponent(this.opts.projectId)}`,
+      { method: "DELETE" }
+    );
+    return { released: true };
+  }
+  async getUsage(range = {}) {
+    const q = new URLSearchParams();
+    if (range.from) q.set("from", range.from);
+    if (range.to) q.set("to", range.to);
+    const path = `/api/voice/usage/${encodeURIComponent(this.opts.projectId)}${q.toString() ? `?${q.toString()}` : ""}`;
+    return this.request(path, { method: "GET" });
+  }
+  async listCalls(opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.limit) q.set("limit", String(opts.limit));
+    if (opts.includeTranscript) q.set("includeTranscript", "1");
+    const path = `/api/voice/calls/${encodeURIComponent(this.opts.projectId)}${q.toString() ? `?${q.toString()}` : ""}`;
+    const res = await this.request(
+      path,
+      { method: "GET" }
+    );
+    return res.calls;
+  }
+  async getCall(callId) {
+    const path = `/api/voice/calls/${encodeURIComponent(
+      this.opts.projectId
+    )}/${encodeURIComponent(callId)}`;
+    return this.request(path, { method: "GET" });
+  }
+};
+var HostedRuntimeTokenClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.mode = "hosted";
+    if (!opts.runtimeToken) {
+      throw new TelephonyConfigError(
+        "Runtime-token telephony requires runtimeToken (process.env.RUNTIME_AUTH_SECRET)"
+      );
+    }
+    if (!opts.projectId) {
+      throw new TelephonyConfigError("Runtime-token telephony requires projectId");
+    }
+    if (!opts.apiUrl) {
+      throw new TelephonyConfigError("Runtime-token telephony requires apiUrl");
+    }
+    this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (typeof this.fetchImpl !== "function") {
+      throw new TelephonyConfigError("global fetch is unavailable; pass opts.fetch");
+    }
+  }
+  url(path) {
+    const base = this.opts.apiUrl.replace(/\/+$/, "");
+    const sep = path.includes("?") ? "&" : "?";
+    return `${base}${path}${sep}projectId=${encodeURIComponent(this.opts.projectId)}`;
+  }
+  async request(path, init = {}) {
+    const headers = {
+      "x-runtime-token": this.opts.runtimeToken,
+      ...init.headers
+    };
+    let body = init.body;
+    if (init.json !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(init.json);
+    }
+    const res = await this.fetchImpl(this.url(path), {
+      ...init,
+      headers,
+      body,
+      credentials: "omit"
+    });
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      const message = parsed?.error ?? parsed?.message ?? `Shogo API error: ${res.status}`;
+      throw new TelephonyApiError(message, res.status, parsed);
+    }
+    return parsed;
+  }
+  async provisionNumber(opts = {}) {
+    const data = await this.request(
+      `/api/voice/twilio/provision-number/${encodeURIComponent(
+        this.opts.projectId
+      )}`,
+      {
+        method: "POST",
+        json: {
+          areaCode: opts.areaCode,
+          country: opts.country,
+          friendlyName: opts.friendlyName
+        }
+      }
+    );
+    return {
+      phoneNumber: data.phoneNumber,
+      twilioPhoneSid: data.twilioPhoneSid,
+      elevenlabsPhoneId: data.elevenlabsPhoneId,
+      setupBilledUsd: data.setupBilledUsd,
+      monthlyBilledUsd: data.monthlyBilledUsd,
+      usageDebited: data.usageDebited
+    };
+  }
+  async outboundCall(opts) {
+    const data = await this.request(
+      `/api/voice/twilio/outbound/${encodeURIComponent(this.opts.projectId)}`,
+      {
+        method: "POST",
+        json: { to: opts.to, dynamicVariables: opts.dynamicVariables }
+      }
+    );
+    return {
+      callSid: data.callSid,
+      conversationId: data.conversationId,
+      estimatedBilledUsd: data.estimatedBilledUsd,
+      billedUsdPerMinute: data.billedUsdPerMinute
+    };
+  }
+  async releaseNumber() {
+    await this.request(
+      `/api/voice/twilio/number/${encodeURIComponent(this.opts.projectId)}`,
+      { method: "DELETE" }
+    );
+    return { released: true };
+  }
+  async getUsage(range = {}) {
+    const q = new URLSearchParams();
+    if (range.from) q.set("from", range.from);
+    if (range.to) q.set("to", range.to);
+    const path = `/api/voice/usage/${encodeURIComponent(this.opts.projectId)}${q.toString() ? `?${q.toString()}` : ""}`;
+    return this.request(path, { method: "GET" });
+  }
+  async listCalls(opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.limit) q.set("limit", String(opts.limit));
+    if (opts.includeTranscript) q.set("includeTranscript", "1");
+    const path = `/api/voice/calls/${encodeURIComponent(this.opts.projectId)}${q.toString() ? `?${q.toString()}` : ""}`;
+    const res = await this.request(
+      path,
+      { method: "GET" }
+    );
+    return res.calls;
+  }
+  async getCall(callId) {
+    const path = `/api/voice/calls/${encodeURIComponent(
+      this.opts.projectId
+    )}/${encodeURIComponent(callId)}`;
+    return this.request(path, { method: "GET" });
+  }
+};
+var DirectTelephonyClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.mode = "direct";
+    if (!opts.elevenlabs?.apiKey) {
+      throw new TelephonyConfigError("Direct telephony requires elevenlabs.apiKey");
+    }
+    if (!opts.elevenlabs?.agentId) {
+      throw new TelephonyConfigError("Direct telephony requires elevenlabs.agentId");
+    }
+    if (!opts.twilio?.accountSid || !opts.twilio?.authToken) {
+      throw new TelephonyConfigError(
+        "Direct telephony requires twilio.accountSid + twilio.authToken"
+      );
+    }
+    this.el = new ElevenLabsClient({
+      apiKey: opts.elevenlabs.apiKey,
+      baseUrl: opts.elevenlabs.baseUrl,
+      fetch: opts.fetch
+    });
+    this.tw = new TwilioClient({
+      accountSid: opts.twilio.accountSid,
+      authToken: opts.twilio.authToken,
+      baseUrl: opts.twilio.baseUrl,
+      fetch: opts.fetch
+    });
+    this.state = {
+      phoneNumber: opts.twilio.fromNumber,
+      twilioSid: opts.twilio.phoneSid,
+      elevenlabsPhoneId: opts.elevenlabs.phoneNumberId
+    };
+  }
+  async provisionNumber(opts = {}) {
+    const candidates = await this.tw.searchAvailable({
+      country: opts.country,
+      areaCode: opts.areaCode,
+      limit: 1
+    });
+    if (candidates.length === 0) {
+      throw new TelephonyApiError(
+        "No Twilio numbers available matching criteria",
+        404,
+        { areaCode: opts.areaCode, country: opts.country }
+      );
+    }
+    const purchased = await this.tw.purchaseNumber({
+      phoneNumber: candidates[0].phoneNumber,
+      friendlyName: opts.friendlyName
+    });
+    try {
+      const { phoneNumberId } = await this.el.createPhoneNumberTwilio({
+        phoneNumber: purchased.phoneNumber,
+        label: opts.friendlyName ?? purchased.phoneNumber,
+        agentId: this.opts.elevenlabs.agentId,
+        twilioAccountSid: this.opts.twilio.accountSid,
+        twilioAuthToken: this.opts.twilio.authToken
+      });
+      this.state = {
+        phoneNumber: purchased.phoneNumber,
+        twilioSid: purchased.sid,
+        elevenlabsPhoneId: phoneNumberId
+      };
+      return {
+        phoneNumber: purchased.phoneNumber,
+        twilioPhoneSid: purchased.sid,
+        elevenlabsPhoneId: phoneNumberId
+      };
+    } catch (err) {
+      try {
+        await this.tw.releaseNumber(purchased.sid);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  async outboundCall(opts) {
+    if (!this.state.elevenlabsPhoneId) {
+      throw new TelephonyConfigError(
+        "outboundCall requires an ElevenLabs phone id; call provisionNumber() or pass elevenlabs.phoneNumberId"
+      );
+    }
+    const res = await this.el.outboundCall({
+      phoneNumberId: this.state.elevenlabsPhoneId,
+      agentId: this.opts.elevenlabs.agentId,
+      toNumber: opts.to,
+      dynamicVariables: opts.dynamicVariables
+    });
+    return { callSid: res.callSid, conversationId: res.conversationId };
+  }
+  async releaseNumber() {
+    let released = false;
+    if (this.state.elevenlabsPhoneId) {
+      await this.el.deletePhoneNumber(this.state.elevenlabsPhoneId);
+      released = true;
+    }
+    if (this.state.twilioSid) {
+      await this.tw.releaseNumber(this.state.twilioSid);
+      released = true;
+    }
+    this.state = {};
+    return { released };
+  }
+  async getUsage() {
+    throw new TelephonyConfigError(
+      "getUsage() is unavailable in Mode A (self-hosted). Query Twilio + ElevenLabs directly."
+    );
+  }
+  async listCalls() {
+    throw new TelephonyConfigError(
+      "listCalls() is unavailable in Mode A (self-hosted). Query ElevenLabs conversations directly."
+    );
+  }
+  async getCall() {
+    throw new TelephonyConfigError(
+      "getCall() is unavailable in Mode A (self-hosted). Query ElevenLabs conversations directly."
+    );
+  }
+};
+function createTelephonyClient(opts) {
+  if (opts.mode === "hosted") return new HostedTelephonyClient(opts);
+  if (opts.mode === "runtime-token") return new HostedRuntimeTokenClient(opts);
+  return new DirectTelephonyClient(opts);
+}
+
+// src/mock-telephony.ts
+var DEFAULT_PHONE = "+14155550143";
+var DEFAULT_TWILIO_SID = "PNmock0000000000000000000000000001";
+var DEFAULT_EL_PHONE_ID = "phn_mock_0000000001";
+var DEFAULT_CALL_FIXTURES = [
+  {
+    id: "mock_call_001",
+    conversationId: "mock_conv_001",
+    callSid: "CAmock00000000000000000000000000001",
+    direction: "outbound",
+    durationSeconds: 184,
+    billedMinutes: 4,
+    startedAt: "2026-05-06T22:01:00.000Z",
+    endedAt: "2026-05-06T22:04:04.000Z",
+    createdAt: "2026-05-06T22:01:00.000Z",
+    billed: true,
+    hasTranscript: true,
+    transcriptSummary: "Prospect agreed to a 30-min demo on Thursday at 2pm PT. Booked via Calendly link."
+  },
+  {
+    id: "mock_call_002",
+    conversationId: "mock_conv_002",
+    callSid: "CAmock00000000000000000000000000002",
+    direction: "outbound",
+    durationSeconds: 41,
+    billedMinutes: 1,
+    startedAt: "2026-05-06T22:05:00.000Z",
+    endedAt: "2026-05-06T22:05:41.000Z",
+    createdAt: "2026-05-06T22:05:00.000Z",
+    billed: true,
+    hasTranscript: true,
+    transcriptSummary: "Voicemail. Left a 25-second AI-disclosed message with callback number."
+  },
+  {
+    id: "mock_call_003",
+    conversationId: "mock_conv_003",
+    callSid: "CAmock00000000000000000000000000003",
+    direction: "outbound",
+    durationSeconds: 22,
+    billedMinutes: 1,
+    startedAt: "2026-05-06T22:06:30.000Z",
+    endedAt: "2026-05-06T22:06:52.000Z",
+    createdAt: "2026-05-06T22:06:30.000Z",
+    billed: true,
+    hasTranscript: true,
+    transcriptSummary: 'Prospect said "remove me" 8 seconds in. Honored, persisted to do-not-call list.'
+  }
+];
+var DEFAULT_TRANSCRIPTS = {
+  mock_conv_001: [
+    { role: "agent", message: "Hi, this is an AI assistant calling on behalf of Russell at Shogo. Do you have 30 seconds?", time_in_call_secs: 1 },
+    { role: "user", message: "Sure, what is this about?", time_in_call_secs: 6 },
+    { role: "agent", message: "Shogo is a universal AI agent that runs every job-to-be-done with real interfaces, not chat. We help teams like yours replace point tools with one platform.", time_in_call_secs: 10 },
+    { role: "user", message: "Interesting. We've been looking at workflow automation. How is this different from Zapier?", time_in_call_secs: 24 },
+    { role: "agent", message: "Zapier connects steps. Shogo runs the whole workflow with an agent that can use tools, build interfaces, and learn from your data.", time_in_call_secs: 30 },
+    { role: "user", message: "OK I'd like to see it. Send me a demo invite.", time_in_call_secs: 52 },
+    { role: "agent", message: "Great. I'm sending the Calendly link now. Does Thursday at 2pm Pacific work?", time_in_call_secs: 58 },
+    { role: "user", message: "Yes, perfect.", time_in_call_secs: 66 },
+    { role: "agent", message: "Booked. You'll get a confirmation email in 30 seconds. Thanks for your time.", time_in_call_secs: 70 }
+  ],
+  mock_conv_002: [
+    { role: "agent", message: "Hi, this is an AI assistant calling on behalf of Russell at Shogo. Leaving a voicemail \u2014 we'd love to show you our universal AI agent platform. Call us back at +1 415 555 0143 or visit shogo.ai. Have a great day.", time_in_call_secs: 1 }
+  ],
+  mock_conv_003: [
+    { role: "agent", message: "Hi, this is an AI assistant calling on behalf of Russell at Shogo \u2014", time_in_call_secs: 1 },
+    { role: "user", message: "Remove me from your list.", time_in_call_secs: 8 },
+    { role: "agent", message: "Understood. You're removed and we won't call again. Thank you.", time_in_call_secs: 11 }
+  ]
+};
+var warned = false;
+var MockTelephonyClient = class {
+  constructor(opts = {}) {
+    this.mode = "mock";
+    this.callCounter = 0;
+    this.projectId = opts.projectId ?? "demo-project";
+    this.phoneNumber = opts.phoneNumber ?? DEFAULT_PHONE;
+    this.fixtures = opts.callFixtures ?? DEFAULT_CALL_FIXTURES;
+    if (!warned) {
+      console.warn(
+        "[shogo] voice mock mode active \u2014 telephony returns canned data, no real provider calls are made."
+      );
+      warned = true;
+    }
+  }
+  async provisionNumber(_opts = {}) {
+    return {
+      phoneNumber: this.phoneNumber,
+      twilioPhoneSid: DEFAULT_TWILIO_SID,
+      elevenlabsPhoneId: DEFAULT_EL_PHONE_ID,
+      setupBilledUsd: 0,
+      monthlyBilledUsd: 0,
+      usageDebited: { setup: false, monthly: false }
+    };
+  }
+  async outboundCall(_opts) {
+    this.callCounter++;
+    const seq = String(this.callCounter).padStart(32, "0").slice(-32);
+    return {
+      callSid: `CAmock${seq}`,
+      conversationId: `mock_conv_${String(this.callCounter).padStart(3, "0")}`,
+      estimatedBilledUsd: 0,
+      billedUsdPerMinute: 0
+    };
+  }
+  async releaseNumber() {
+    return { released: true };
+  }
+  async getUsage(_range) {
+    const outboundCalls = this.fixtures.filter((c) => c.direction === "outbound").length;
+    const inboundCalls = this.fixtures.length - outboundCalls;
+    const totalMinutes = this.fixtures.reduce((sum, c) => sum + c.billedMinutes, 0);
+    return {
+      projectId: this.projectId,
+      range: { from: null, to: null },
+      totals: {
+        minutesInbound: 0,
+        minutesOutbound: totalMinutes,
+        billedUsdInbound: 0,
+        billedUsdOutbound: 0,
+        billedUsdNumbers: 0,
+        billedUsd: 0,
+        calls: this.fixtures.length,
+        inboundCalls,
+        outboundCalls
+      },
+      events: []
+    };
+  }
+  async listCalls(opts = {}) {
+    const limit = opts.limit ?? this.fixtures.length;
+    const slice = this.fixtures.slice(0, limit);
+    if (!opts.includeTranscript) return slice.map((c) => ({ ...c }));
+    return slice.map((c) => ({
+      ...c,
+      transcript: DEFAULT_TRANSCRIPTS[c.conversationId ?? ""] ?? null
+    }));
+  }
+  async getCall(callId) {
+    const found = this.fixtures.find(
+      (c) => c.id === callId || c.conversationId === callId || c.callSid === callId
+    );
+    if (!found) {
+      return {
+        id: callId,
+        conversationId: callId,
+        callSid: callId,
+        direction: "outbound",
+        durationSeconds: 0,
+        billedMinutes: 0,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        billed: false,
+        transcriptSummary: null,
+        transcript: null
+      };
+    }
+    const { hasTranscript: _hasTranscript, ...rest } = found;
+    return {
+      ...rest,
+      transcript: DEFAULT_TRANSCRIPTS[found.conversationId ?? ""] ?? null
+    };
+  }
+};
+function isVoiceMockEnv() {
+  if (typeof process === "undefined") return false;
+  const value = process.env?.SHOGO_VOICE_MODE;
+  if (!value) return false;
+  const v = value.toLowerCase();
+  return v === "mock" || v === "demo" || v === "fake";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUDIO_TAGS,
+  AUDIO_TAG_GROUPS,
+  CONVAI_SUPPORTED_TTS_MODELS,
+  CONVAI_TTS_MODEL_FALLBACK,
+  DEFAULT_ALLOWED_TAGS,
+  DEFAULT_ELEVENLABS_BASE_URL,
+  DEFAULT_MEMORY_BLOCK,
+  DEFAULT_TWILIO_BASE_URL,
+  DEFAULT_VOICE_SETTINGS,
+  DirectTelephonyClient,
+  EXPRESSIVITY_BLOCK_CLOSE,
+  EXPRESSIVITY_BLOCK_OPEN,
+  EXPRESSIVITY_OPTIONS,
+  ElevenLabsApiError,
+  ElevenLabsClient,
+  HostedRuntimeTokenClient,
+  HostedTelephonyClient,
+  MEMORY_CLIENT_TOOLS,
+  MockTelephonyClient,
+  TelephonyApiError,
+  TelephonyConfigError,
+  TwilioApiError,
+  TwilioClient,
+  buildPreviewLine,
+  composeAgentPrompt,
+  composeExpressivityBlock,
+  createTelephonyClient,
+  extractBasePrompt,
+  isVoiceMockEnv,
+  normalizeAudioTags,
+  normalizeExpressivity,
+  normalizeVoiceSettings,
+  readAudioTags,
+  readExpressivity,
+  readVoiceSettings,
+  resolveConvaiTtsModel,
+  stripAudioTags,
+  stripExpressivityBlock,
+  stripMemoryBlock
+});
+//# sourceMappingURL=index.cjs.map