@shogo-ai/voice 1.10.0 → 2.4.2

package/dist/chunk-U5UC7ZVS.js

@@ -0,0 +1,988 @@
+import {
+  CONVAI_TTS_MODEL_FALLBACK,
+  DEFAULT_TTS_MODEL,
+  ElevenLabsApiError,
+  ElevenLabsClient,
+  MEMORY_CLIENT_TOOLS,
+  VOICE_OP_IDS,
+  extractBasePrompt,
+  getVoiceOp,
+  parseVoiceOpForm,
+  parseVoiceOpJsonBody,
+  readRuntimeAuthSecret,
+  resolveConvaiTtsModel,
+  voiceOpForwardPath,
+  voiceOpPathParams,
+  voiceOpReturnsAudio,
+  voiceOpUpstreamBody,
+  voiceOpUpstreamPath
+} from "./chunk-IOFWML5L.js";
+import {
+  AUDIO_TAGS,
+  AUDIO_TAG_GROUPS,
+  DEFAULT_ALLOWED_TAGS,
+  DEFAULT_VOICE_SETTINGS,
+  EXPRESSIVITY_OPTIONS,
+  buildPreviewLine,
+  normalizeAudioTags,
+  normalizeExpressivity,
+  normalizeVoiceSettings,
+  readAudioTags,
+  readExpressivity,
+  readVoiceSettings
+} from "./chunk-Q3TJAJ54.js";
+
+// 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 parseMusicBody(raw) {
+  if (raw === null || typeof raw !== "object") return { error: "Invalid JSON body" };
+  const b = raw;
+  const hasPrompt = typeof b.prompt === "string" && b.prompt.trim().length > 0;
+  const hasPlan = b.compositionPlan != null && typeof b.compositionPlan === "object";
+  if (hasPrompt === hasPlan) {
+    return { error: "Provide exactly one of `prompt` or `compositionPlan`" };
+  }
+  const params = {};
+  if (hasPrompt) {
+    params.prompt = b.prompt.trim();
+    if (typeof b.musicLengthMs === "number") params.musicLengthMs = b.musicLengthMs;
+    if (typeof b.forceInstrumental === "boolean") params.forceInstrumental = b.forceInstrumental;
+  } else {
+    params.compositionPlan = b.compositionPlan;
+  }
+  if (typeof b.modelId === "string" && b.modelId.length > 0) params.modelId = b.modelId;
+  if (typeof b.outputFormat === "string" && b.outputFormat.length > 0) {
+    params.outputFormat = b.outputFormat;
+  }
+  return { params };
+}
+var MISSING_API_HOST_MESSAGE = "createVoiceHandlers: runtime-token proxy mode needs SHOGO_API_URL (or SHOGO_CLOUD_URL) in env; refusing to guess an API host";
+function envApiUrl() {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  return process.env.SHOGO_API_URL ?? process.env.SHOGO_CLOUD_URL;
+}
+function resolveProxyOptions(config) {
+  if (config.mode === "byo") {
+    if (config.proxy) {
+      throw new Error(
+        "createVoiceHandlers: mode 'byo' cannot be combined with an explicit proxy"
+      );
+    }
+    return null;
+  }
+  const envProxy = () => {
+    if (config.mode === "proxy" && config.apiKey) {
+      LOG_WARN_CACHE.apiKeyIgnored(config.logger);
+    }
+    if (typeof process === "undefined" || !process.env) return null;
+    const runtimeToken = readRuntimeAuthSecret();
+    const projectId = process.env.PROJECT_ID;
+    if (!runtimeToken || !projectId) return null;
+    return {
+      runtimeToken,
+      projectId,
+      // Deliberately not required here: see `resolveApiBase`. Throwing at
+      // construction made every local-only handler (400 validation, 405s,
+      // the static audio-tags catalog) unusable on a host with a token but
+      // no URL — which is exactly CI's env.
+      apiUrl: envApiUrl() ?? "",
+      ...config.fetch ? { fetch: config.fetch } : {}
+    };
+  };
+  if (config.proxy) {
+    if (!config.proxy.runtimeToken || !config.proxy.projectId || !config.proxy.apiUrl) {
+      throw new Error(
+        "createVoiceHandlers: proxy requires runtimeToken, projectId, and apiUrl"
+      );
+    }
+    if (config.apiKey) LOG_WARN_CACHE.apiKeyIgnored(config.logger);
+    return config.proxy;
+  }
+  if (config.mode === "proxy") return envProxy();
+  if (config.apiKey) return null;
+  return envProxy();
+}
+var LOG_WARN_CACHE = {
+  warned: false,
+  apiKeyIgnored(logger) {
+    if (LOG_WARN_CACHE.warned) return;
+    LOG_WARN_CACHE.warned = true;
+    (logger ?? NOOP_LOGGER)(
+      "warn",
+      'createVoiceHandlers: apiKey provided but runtime-token proxy mode is active; apiKey is ignored (pass mode: "byo" to use it)'
+    );
+  }
+};
+function resolveOpId(req, opId) {
+  if (opId) return opId;
+  try {
+    const url = new URL(req.url);
+    const fromQuery = url.searchParams.get("op");
+    if (fromQuery) return fromQuery;
+    const segments = url.pathname.split("/").filter(Boolean);
+    const last = segments[segments.length - 1];
+    if (last && segments[segments.length - 2] === "op") return last;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readVoiceOpBody(op, req) {
+  if (op.method === "GET") return { kind: "none" };
+  if (op.transport === "multipart-binary" || op.transport === "multipart-json") {
+    let form;
+    try {
+      form = await req.formData();
+    } catch {
+      return json({ error: "Invalid multipart body", detail: "send a multipart/form-data body" }, 400);
+    }
+    const parsed2 = parseVoiceOpForm(op, form);
+    if (!parsed2.ok) {
+      return json(
+        {
+          error: parsed2.error,
+          ...parsed2.detail ? { detail: parsed2.detail } : {},
+          ...parsed2.allowed ? { allowed: parsed2.allowed } : {}
+        },
+        parsed2.status
+      );
+    }
+    return { kind: "form", form: parsed2.form, fields: parsed2.fields };
+  }
+  const raw = await readJson(req);
+  const parsed = parseVoiceOpJsonBody(op, raw);
+  if (!parsed.ok) {
+    return json(
+      {
+        error: parsed.error,
+        ...parsed.detail ? { detail: parsed.detail } : {},
+        ...parsed.allowed ? { allowed: parsed.allowed } : {}
+      },
+      parsed.status
+    );
+  }
+  return { kind: "json", fields: parsed.fields };
+}
+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"
+    );
+  }
+  function resolveApiBase() {
+    const raw = proxy.apiUrl || envApiUrl();
+    if (!raw) throw new Error(MISSING_API_HOST_MESSAGE);
+    return raw.replace(/\/+$/, "");
+  }
+  function proxyUrl(base, 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 `${base}${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);
+    const base = resolveApiBase();
+    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(base, "/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
+      }
+    });
+  }
+  async function doOp(req, opId) {
+    const id = resolveOpId(req, opId);
+    const op = getVoiceOp(id);
+    if (!op) {
+      return json(
+        { error: "unknown_op", detail: `Unknown voice op '${id ?? ""}'`, allowed: VOICE_OP_IDS },
+        404
+      );
+    }
+    if (req.method !== op.method) return json({ error: "Method Not Allowed" }, 405);
+    const parsed = await readVoiceOpBody(op, req);
+    if (parsed instanceof Response) return parsed;
+    const base = resolveApiBase();
+    const forward = {};
+    let incomingUrl = null;
+    try {
+      incomingUrl = new URL(req.url);
+    } catch {
+    }
+    if (incomingUrl) {
+      for (const key of [...op.pathParams ?? [], ...op.queryForward ?? []]) {
+        const value = incomingUrl.searchParams.get(key);
+        if (value != null) forward[key] = value;
+      }
+    }
+    if (parsed.kind === "form") {
+      for (const name of op.pathParams ?? []) {
+        const value = parsed.fields[name];
+        if (typeof value === "string" && value.length > 0) forward[name] = value;
+      }
+    }
+    const hostedPath = `/api${voiceOpForwardPath(op)}`;
+    const headers = { "x-runtime-token": proxy.runtimeToken };
+    let body;
+    if (parsed.kind === "json") {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(parsed.fields);
+    } else if (parsed.kind === "form") {
+      body = parsed.form;
+    }
+    if (op.accept) headers.accept = op.accept;
+    try {
+      const upstream = await fetchImpl(proxyUrl(base, hostedPath, forward), {
+        method: op.method,
+        headers,
+        ...body !== void 0 ? { body } : {},
+        credentials: "omit"
+      });
+      if (upstream.status === 404) {
+        return json(
+          {
+            error: "Not Implemented",
+            detail: `this Shogo API has no voice routes (desktop without ELEVENLABS_API_KEY?) \u2014 ${hostedPath} returned 404 upstream`
+          },
+          501
+        );
+      }
+      const buf = await upstream.arrayBuffer();
+      const responseHeaders = {};
+      const ct = upstream.headers.get("content-type");
+      if (ct) responseHeaders["content-type"] = ct;
+      for (const name of op.responseHeaders ?? []) {
+        const value = upstream.headers.get(name);
+        if (value) responseHeaders[name] = value;
+      }
+      return new Response(buf, { status: upstream.status, headers: responseHeaders });
+    } catch (err) {
+      log("error", `proxy ${op.id} failed`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return json({ error: `${op.id} proxy failed` }, 502);
+    }
+  }
+  const doMusic = (req) => doOp(req, "music");
+  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
+    );
+  }
+  async function doTts(req) {
+    if (req.method === "POST") {
+      let raw = null;
+      try {
+        const parsed = await req.clone().json();
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          raw = parsed;
+        }
+      } catch {
+      }
+      if (raw && (typeof raw.text !== "string" || raw.text.trim().length === 0)) {
+        const sentTags = Array.isArray(raw.audioTags) && raw.audioTags.length > 0;
+        if (sentTags) {
+          const tags = normalizeAudioTags(raw.audioTags) ?? [];
+          const characterName = typeof raw.characterName === "string" ? raw.characterName : void 0;
+          const text = buildPreviewLine(tags, characterName ?? "your companion");
+          return doOp(
+            new Request(req.url, {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ ...raw, text })
+            }),
+            "text-to-speech"
+          );
+        }
+      }
+    }
+    return doOp(req, "text-to-speech");
+  }
+  function createProxyElevenLabs() {
+    const unsupported = (prop) => {
+      throw new Error(
+        `createVoiceHandlers: elevenLabs.${prop} is not available in runtime-token proxy mode (textToSpeech, composeMusic, speechToSpeech, soundEffects and transcribe are hosted); pass mode: 'byo' with an apiKey`
+      );
+    };
+    const textToSpeech = async (params) => {
+      const upstream = await fetchImpl(proxyUrl(resolveApiBase(), "/api/voice/tts", {}), {
+        method: "POST",
+        headers: {
+          "x-runtime-token": proxy.runtimeToken,
+          "content-type": "application/json",
+          accept: params.accept ?? "audio/mpeg"
+        },
+        body: JSON.stringify({
+          text: params.text,
+          voiceId: params.voiceId,
+          ...params.modelId ? { modelId: params.modelId } : {},
+          ...params.voiceSettings ? { voiceSettings: params.voiceSettings } : {}
+        }),
+        credentials: "omit"
+      });
+      if (upstream.status === 404) {
+        throw new Error(
+          "this Shogo API has no voice routes (desktop without ELEVENLABS_API_KEY?) \u2014 /api/voice/tts returned 404 upstream"
+        );
+      }
+      if (!upstream.ok) {
+        throw new ElevenLabsApiError(
+          `textToSpeech failed: ${upstream.status}`,
+          upstream.status,
+          await upstream.text()
+        );
+      }
+      const requestedModel = params.modelId ?? DEFAULT_TTS_MODEL;
+      const usedModel = upstream.headers.get("x-tts-model-used") ?? requestedModel;
+      const requestedHeader = upstream.headers.get("x-tts-model-requested") ?? requestedModel;
+      return {
+        audio: await upstream.arrayBuffer(),
+        modelId: usedModel,
+        requestedModel: requestedHeader,
+        fellBack: usedModel !== requestedHeader,
+        contentType: upstream.headers.get("content-type") ?? params.accept ?? "audio/mpeg"
+      };
+    };
+    const composeMusic = async (params) => {
+      const upstream = await fetchImpl(proxyUrl(resolveApiBase(), "/api/voice/music", {}), {
+        method: "POST",
+        headers: {
+          "x-runtime-token": proxy.runtimeToken,
+          "content-type": "application/json",
+          accept: "audio/mpeg"
+        },
+        body: JSON.stringify(params),
+        credentials: "omit"
+      });
+      if (upstream.status === 404) {
+        throw new Error(
+          "this Shogo API has no voice routes (desktop without ELEVENLABS_API_KEY?) \u2014 /api/voice/music returned 404 upstream"
+        );
+      }
+      if (!upstream.ok) {
+        throw new ElevenLabsApiError(
+          `composeMusic failed: ${upstream.status}`,
+          upstream.status,
+          await upstream.text()
+        );
+      }
+      return {
+        audio: await upstream.arrayBuffer(),
+        contentType: upstream.headers.get("content-type") ?? "audio/mpeg"
+      };
+    };
+    const opResponse = async (opId, req) => {
+      const op = getVoiceOp(opId);
+      const res = await doOp(req, opId);
+      if (res.status === 404) {
+        throw new Error(
+          `this Shogo API has no voice routes (desktop without ELEVENLABS_API_KEY?) \u2014 /api${voiceOpForwardPath(op)} returned 404 upstream`
+        );
+      }
+      if (!res.ok) {
+        throw new ElevenLabsApiError(
+          `${opId} failed: ${res.status}`,
+          res.status,
+          await res.text()
+        );
+      }
+      return res;
+    };
+    const opAudio = async (opId, req) => {
+      const res = await opResponse(opId, req);
+      return {
+        audio: await res.arrayBuffer(),
+        contentType: res.headers.get("content-type") ?? "audio/mpeg"
+      };
+    };
+    const speechToSpeech = (params) => {
+      const form = new FormData();
+      form.set("audio", params.audio, params.fileName ?? "audio");
+      if (params.modelId) form.set("modelId", params.modelId);
+      if (params.voiceSettings) form.set("voiceSettings", JSON.stringify(params.voiceSettings));
+      if (params.outputFormat) form.set("outputFormat", params.outputFormat);
+      if (params.fileFormat) form.set("fileFormat", params.fileFormat);
+      if (params.seed !== void 0) form.set("seed", String(params.seed));
+      if (params.removeBackgroundNoise !== void 0) {
+        form.set("removeBackgroundNoise", String(params.removeBackgroundNoise));
+      }
+      const query = `?voiceId=${encodeURIComponent(params.voiceId)}`;
+      return opAudio(
+        "speech-to-speech",
+        new Request(`http://voice.invalid/voice/op/speech-to-speech${query}`, {
+          method: "POST",
+          body: form
+        })
+      );
+    };
+    const soundEffects = (params) => opAudio(
+      "sound-generation",
+      new Request(
+        // `output_format` is a query param on this endpoint (see the row's
+        // `queryForward`); sending it in the body would be dropped at EL.
+        `http://voice.invalid/voice/op/sound-generation${params.outputFormat ? `?output_format=${encodeURIComponent(params.outputFormat)}` : ""}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            text: params.text,
+            ...params.durationSeconds !== void 0 ? { durationSeconds: params.durationSeconds } : {},
+            ...params.promptInfluence !== void 0 ? { promptInfluence: params.promptInfluence } : {},
+            ...params.loop !== void 0 ? { loop: params.loop } : {},
+            ...params.modelId ? { modelId: params.modelId } : {}
+          })
+        }
+      )
+    );
+    const transcribe = async (params) => {
+      const form = new FormData();
+      form.set("file", params.file, params.fileName ?? "audio");
+      if (params.modelId) form.set("modelId", params.modelId);
+      if (params.languageCode) form.set("languageCode", params.languageCode);
+      if (params.diarize !== void 0) form.set("diarize", String(params.diarize));
+      if (params.tagAudioEvents !== void 0) {
+        form.set("tagAudioEvents", String(params.tagAudioEvents));
+      }
+      if (params.numSpeakers !== void 0) form.set("numSpeakers", String(params.numSpeakers));
+      const res = await opResponse(
+        "speech-to-text",
+        new Request("http://voice.invalid/voice/op/speech-to-text", {
+          method: "POST",
+          body: form
+        })
+      );
+      return await res.json();
+    };
+    return new Proxy({}, {
+      get(_t, prop) {
+        if (prop === "textToSpeech") return textToSpeech;
+        if (prop === "composeMusic") return composeMusic;
+        if (prop === "speechToSpeech") return speechToSpeech;
+        if (prop === "soundEffects") return soundEffects;
+        if (prop === "transcribe") return transcribe;
+        return unsupported(String(prop));
+      }
+    });
+  }
+  return {
+    signedUrl: doSignedUrl,
+    tts: doTts,
+    music: doMusic,
+    agent: {
+      create: notImplemented("agent.create"),
+      patch: notImplemented("agent.patch"),
+      delete: notImplemented("agent.delete")
+    },
+    audioTags: doAudioTags,
+    op: doOp,
+    // In proxy mode we don't own an EL client: media calls go through the
+    // Shogo API, anything else is a loud error.
+    elevenLabs: createProxyElevenLabs()
+  };
+}
+function createVoiceHandlers(config) {
+  const log = config.logger ?? NOOP_LOGGER;
+  const proxy = resolveProxyOptions(config);
+  if (proxy) {
+    return createProxyHandlers(proxy, log);
+  }
+  if (!config.apiKey) {
+    throw new Error(
+      config.mode === "proxy" ? 'createVoiceHandlers: mode "proxy" needs RUNTIME_AUTH_SECRET + PROJECT_ID (+ SHOGO_API_URL) in env' : "createVoiceHandlers: apiKey is required (or run in a pod with RUNTIME_AUTH_SECRET + PROJECT_ID for proxy mode)"
+    );
+  }
+  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) {
+    if (!getUser) {
+      return json(
+        {
+          error: "Voice handler misconfigured",
+          detail: "signedUrl / agent.* need getUser (and companionStore); tts and music do not."
+        },
+        500
+      );
+    }
+    const u = await getUser(req);
+    if (!u) return json({ error: "Unauthorized" }, 401);
+    return u;
+  }
+  function missingCompanionStore() {
+    return json(
+      {
+        error: "Voice handler misconfigured",
+        detail: "companionStore is required for signedUrl / agent.*; tts and music do not need it."
+      },
+      500
+    );
+  }
+  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;
+    if (!companionStore) return missingCompanionStore();
+    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);
+    if (getUser) {
+      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 result = await el.textToSpeech({
+        voiceId,
+        text,
+        ...body.modelId ? { modelId: body.modelId } : {},
+        voiceSettings
+      });
+      const headers = {
+        "content-type": result.contentType,
+        "cache-control": "private, max-age=3600",
+        "x-tts-model-used": result.modelId,
+        "x-tts-model-requested": result.requestedModel
+      };
+      if (result.fellBack) {
+        headers.warning = `199 - "model ${result.requestedModel} not available, used ${result.modelId}"`;
+        log("warn", "tts fell back to another model", {
+          requested: result.requestedModel,
+          used: result.modelId,
+          reason: result.fallbackReason
+        });
+      }
+      return new Response(result.audio, { headers });
+    } catch (e) {
+      return handleElError(e, "TTS failed");
+    }
+  }
+  async function doMusic(req) {
+    if (req.method !== "POST") return json({ error: "Method Not Allowed" }, 405);
+    if (getUser) {
+      const u = await resolveUser(req);
+      if (u instanceof Response) return u;
+    }
+    const raw = await readJson(req);
+    const parsed = parseMusicBody(raw);
+    if ("error" in parsed) return json({ error: parsed.error }, 400);
+    try {
+      const { audio, contentType } = await el.composeMusic(parsed.params);
+      return new Response(audio, {
+        headers: {
+          "content-type": contentType,
+          "cache-control": "private, max-age=3600"
+        }
+      });
+    } catch (e) {
+      return handleElError(e, "Music generation failed");
+    }
+  }
+  async function doOp(req, opId) {
+    const id = resolveOpId(req, opId);
+    const op = getVoiceOp(id);
+    if (!op) {
+      return json(
+        { error: "unknown_op", detail: `Unknown voice op '${id ?? ""}'`, allowed: VOICE_OP_IDS },
+        404
+      );
+    }
+    if (req.method !== op.method) return json({ error: "Method Not Allowed" }, 405);
+    const parsed = await readVoiceOpBody(op, req);
+    if (parsed instanceof Response) return parsed;
+    const fields = parsed.kind === "none" ? {} : parsed.fields;
+    let query;
+    try {
+      query = new URL(req.url).searchParams;
+    } catch {
+      query = new URLSearchParams();
+    }
+    const pathParams = voiceOpPathParams(op, fields, query);
+    const upstream = voiceOpUpstreamPath(op, pathParams);
+    if (typeof upstream !== "string") {
+      return json({ error: upstream.error, detail: `set it in the body or as ?${op.pathParams?.[0]}=` }, 400);
+    }
+    const forwardedQuery = {};
+    for (const key of op.queryForward ?? []) {
+      const value = query.get(key);
+      if (value) forwardedQuery[key] = value;
+    }
+    if (op.defaultVoiceId && !pathParams.voiceId) {
+      return json(
+        {
+          error: "Missing `voiceId`",
+          detail: `BYO mode has no project default voice \u2014 pass voiceId (or ?voiceId=)`
+        },
+        400
+      );
+    }
+    try {
+      if (op.call === "textToSpeech") {
+        const result = await el.textToSpeech({
+          voiceId: pathParams.voiceId ?? String(fields.voiceId ?? ""),
+          text: String(fields.text ?? ""),
+          ...typeof fields.modelId === "string" ? { modelId: fields.modelId } : {},
+          ...fields.voiceSettings ? { voiceSettings: fields.voiceSettings } : {},
+          ...op.accept ? { accept: op.accept } : {}
+        });
+        const headers2 = {
+          "content-type": result.contentType,
+          "cache-control": "private, max-age=3600",
+          "x-tts-model-used": result.modelId,
+          "x-tts-model-requested": result.requestedModel
+        };
+        if (result.fellBack) {
+          headers2.warning = `199 - "model ${result.requestedModel} not available, used ${result.modelId}"`;
+        }
+        return new Response(result.audio, { headers: headers2 });
+      }
+      if (op.call === "composeMusic") {
+        const { audio, contentType } = await el.composeMusic({
+          ...typeof fields.prompt === "string" ? { prompt: fields.prompt } : {},
+          ...fields.compositionPlan ? { compositionPlan: fields.compositionPlan } : {},
+          ...typeof fields.musicLengthMs === "number" ? { musicLengthMs: fields.musicLengthMs } : {},
+          ...typeof fields.modelId === "string" ? { modelId: fields.modelId } : {},
+          ...typeof fields.forceInstrumental === "boolean" ? { forceInstrumental: fields.forceInstrumental } : {},
+          ...typeof fields.outputFormat === "string" ? { outputFormat: fields.outputFormat } : {}
+        });
+        return new Response(audio, {
+          headers: {
+            "content-type": contentType,
+            "cache-control": "private, max-age=3600"
+          }
+        });
+      }
+      const upstreamBody = voiceOpUpstreamBody(op, fields);
+      if (op.defaultModel && upstreamBody.model_id === void 0) {
+        upstreamBody.model_id = op.defaultModel;
+      }
+      const response = await el.request({
+        method: op.method,
+        path: upstream,
+        ...parsed.kind === "form" ? { body: parsed.form } : parsed.kind === "json" ? { body: upstreamBody } : {},
+        ...Object.keys(forwardedQuery).length ? { query: forwardedQuery } : {},
+        ...op.accept ? { accept: op.accept } : {}
+      });
+      const headers = { "content-type": response.contentType };
+      if (voiceOpReturnsAudio(op)) headers["cache-control"] = "private, max-age=3600";
+      const body = response.audio ?? JSON.stringify(response.json ?? {});
+      return new Response(body, { status: response.status, headers });
+    } catch (e) {
+      return handleElError(e, `${op.id} 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;
+    if (!companionStore) return missingCompanionStore();
+    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;
+    if (!companionStore) return missingCompanionStore();
+    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;
+    if (!companionStore) return missingCompanionStore();
+    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,
+    music: doMusic,
+    agent: {
+      create: doAgentCreate,
+      patch: doAgentPatch,
+      delete: doAgentDelete
+    },
+    audioTags: doAudioTags,
+    op: doOp,
+    elevenLabs: el
+  };
+}
+function toNodeListener(handler) {
+  return (nodeReq, nodeRes) => {
+    void (async () => {
+      const url = `http://${nodeReq.headers.host ?? "localhost"}${nodeReq.url ?? "/"}`;
+      const chunks = [];
+      for await (const chunk of nodeReq) {
+        chunks.push(chunk);
+      }
+      const body = Buffer.concat(chunks);
+      const init = {
+        method: nodeReq.method,
+        headers: nodeReq.headers
+      };
+      if (body.length > 0) {
+        init.body = body;
+      }
+      const req = new Request(url, init);
+      const res = await handler(req);
+      nodeRes.statusCode = res.status;
+      res.headers.forEach((value, key) => {
+        nodeRes.setHeader(key, value);
+      });
+      const buf = Buffer.from(await res.arrayBuffer());
+      nodeRes.end(buf);
+    })().catch((err) => {
+      nodeRes.statusCode = 500;
+      nodeRes.end(err instanceof Error ? err.message : String(err));
+    });
+  };
+}
+
+export {
+  createVoiceHandlers,
+  toNodeListener
+};
+//# sourceMappingURL=chunk-U5UC7ZVS.js.map