@recombine-ai/platform 0.8.0-test.1 → 0.8.0

package/build/call-control.runtime.js

@@ -1,1057 +0,0 @@
-// src/call-control/types.ts
-import {
-  Room,
-  SIPDispatchRuleInfo as SipDispatchRule,
-  SIPInboundTrunkInfo as SipInboundTrunk,
-  SIPOutboundTrunkInfo as SipOutboundTrunk
-} from "livekit-server-sdk";
-
-// src/call-control/schemas.generated.ts
-import { z } from "zod";
-var configSchema = z.object({
-  agent_background_audio_volume: z.number().default(0.2),
-  agent_background_audio_autopause: z.boolean().default(false),
-  session_turn_detection: z.enum(["stt", "vad", "model"]).describe(
-    "Strategy for deciding when the user has finished speaking. 'stt' relies on speech-to-text end-of-utterance cues, 'vad' relies on Voice Activity Detection start/stop cues, and 'model' uses the audio turn detector"
-  ).default("model"),
-  session_allow_interruptions: z.boolean().describe("Whether the user can interrupt the agent mid-utterance").default(true),
-  agent_dynamic_interruption_escalation: z.boolean().describe(
-    "Whether to dynamically escalate interruption threshold if user does not interrupt within the defined delay after TTS starts"
-  ).default(false),
-  session_min_interruption_words: z.number().int().describe(
-    "Minimum number of transcribed words to consider an interruption (only used when STT is enabled)"
-  ).default(1),
-  session_min_interruption_duration: z.number().describe("Minimum speech length in seconds to register as an interruption").default(0.1),
-  session_min_endpointing_delay: z.number().describe(
-    "Minimum time in seconds since the last detected speech before the agent declares the user's turn complete. In VAD mode behaves like max(VAD silence, min_endpointing_delay); in STT mode applied after the STT end-of-speech signal, so it can be additive with the STT provider's endpointing delay"
-  ).default(0.1),
-  session_max_endpointing_delay: z.number().describe("Maximum time in seconds the agent will wait before terminating the turn").default(3),
-  session_preemptive_generation: z.boolean().describe(
-    "Whether to speculatively begin LLM and TTS requests before end-of-turn is detected. Reduces response latency by overlapping model inference with user audio, but may incur extra compute if the user interrupts mid-utterance"
-  ).default(true),
-  vad_min_speech_duration: z.number().describe("Minimum duration of speech in seconds to start a new speech chunk").default(0.02),
-  vad_min_silence_duration: z.number().describe(
-    "At the end of each speech, wait this duration in seconds before ending the speech. The audio turn detector requires at least 0.25 seconds"
-  ).default(1),
-  vad_prefix_padding_duration: z.number().describe("Duration in seconds of padding to add to the beginning of each speech chunk").default(0.5),
-  vad_max_buffered_speech: z.number().describe("Maximum duration of speech to keep in the buffer, in seconds").default(180),
-  vad_activation_threshold: z.number().describe("Threshold to consider a frame as speech").default(0.1),
-  vad_deactivation_threshold: z.union([z.number(), z.null()]).describe(
-    "Negative threshold (noise or exit threshold). If model's current state is SPEECH, values below this are considered as NON-SPEECH. Default is max(activation_threshold - 0.15, 0.01)"
-  ).default(null),
-  vad_sample_rate: z.union([z.literal(8e3), z.literal(16e3)]).describe("Sample rate for VAD inference (only 8KHz and 16KHz are supported)").default(8e3),
-  stt_api_version: z.union([z.literal(1), z.literal(2)]).describe(
-    "Deepgram API version. Version 1 is the default with rich configuration options. Version 2 uses the Flux model family with end-of-turn detection (eot_threshold, eot_timeout_ms, eager_eot_threshold)"
-  ).default(1),
-  stt_model: z.union([
-    z.literal("flux-general-en"),
-    z.enum([
-      "nova-general",
-      "nova-phonecall",
-      "nova-meeting",
-      "nova-2-general",
-      "nova-2-meeting",
-      "nova-2-phonecall",
-      "nova-2-finance",
-      "nova-2-conversationalai",
-      "nova-2-voicemail",
-      "nova-2-video",
-      "nova-2-medical",
-      "nova-2-drivethru",
-      "nova-2-automotive",
-      "nova-3",
-      "nova-3-general",
-      "nova-3-medical",
-      "enhanced-general",
-      "enhanced-meeting",
-      "enhanced-phonecall",
-      "enhanced-finance",
-      "base",
-      "meeting",
-      "phonecall",
-      "finance",
-      "conversationalai",
-      "voicemail",
-      "video",
-      "whisper-tiny",
-      "whisper-base",
-      "whisper-small",
-      "whisper-medium",
-      "whisper-large"
-    ])
-  ]).describe("The Deepgram model to use for speech recognition").default("nova-3"),
-  stt_language: z.enum([
-    "zh",
-    "zh-CN",
-    "zh-TW",
-    "da",
-    "nl",
-    "en",
-    "en-US",
-    "en-AU",
-    "en-GB",
-    "en-NZ",
-    "en-IN",
-    "fr",
-    "fr-CA",
-    "de",
-    "hi",
-    "hi-Latn",
-    "pt",
-    "pt-BR",
-    "es",
-    "es-419",
-    "it",
-    "ja",
-    "ko",
-    "no",
-    "pl",
-    "es-LATAM",
-    "sv",
-    "ta",
-    "taq",
-    "uk",
-    "tr",
-    "id",
-    "ru",
-    "th",
-    "multi"
-  ]).describe("The language code for recognition").default("en"),
-  stt_detect_language: z.boolean().describe("Whether to enable automatic language detection").default(false),
-  stt_interim_results: z.boolean().describe("Whether to return interim (non-final) transcription results").default(false),
-  stt_punctuate: z.boolean().describe(
-    "Whether to add punctuations to the transcription. Turn detector will work better with punctuations"
-  ).default(true),
-  stt_smart_format: z.boolean().describe("Whether to apply smart formatting to numbers, dates, etc.").default(false),
-  stt_sample_rate: z.number().int().describe("The sample rate of the audio in Hz").default(8e3),
-  stt_no_delay: z.boolean().describe(
-    "When smart_format is used, ensures it does not wait for sequence to be complete before returning results"
-  ).default(true),
-  stt_endpointing_ms: z.number().int().describe("Time in milliseconds of silence to consider end of speech. Set to 0 to disable").default(25),
-  stt_filler_words: z.boolean().describe("Whether to include filler words (um, uh, etc.) in transcription.").default(true),
-  stt_keyterms: z.array(z.string()).describe("Key terms to improve recognition accuracy. Only supported by Nova-3 models").default([]),
-  stt_tags: z.array(z.string()).describe("List of tags to add to the requests for usage reporting.").default([]),
-  stt_profanity_filter: z.boolean().describe("Whether to filter profanity from the transcription.").default(false),
-  stt_eager_eot_threshold: z.union([z.number(), z.null()]).describe(
-    "Threshold for eager end-of-turn to enable preemptive generation. Disabled by default. Set to 0.3-0.9 to enable. Only used when stt_api_version is 2"
-  ).default(null),
-  stt_eot_threshold: z.number().describe("Threshold for end-of-turn detection. Only used when stt_api_version is 2").default(0.7),
-  stt_eot_timeout_ms: z.number().int().describe(
-    "Timeout in milliseconds for end-of-turn detection. Only used when stt_api_version is 2"
-  ).default(3e3),
-  tts_voice_id: z.string().describe("ElevenLabs voice ID (default `bIHbv24MWmeRgasZH58o` used if none set)").default("bIHbv24MWmeRgasZH58o"),
-  tts_voice_similarity_boost: z.number().describe("Voice similarity boost [0.0 - 1.0]").default(0.6),
-  tts_voice_stability: z.number().describe("Voice stability [0.0 - 1.0]").default(0.95),
-  tts_voice_speed: z.number().describe("Voice speed [0.8 - 1.2]").default(1),
-  tts_voice_style: z.number().describe("Voice style exaggeration [0.0 - 1.0]").default(0.1),
-  tts_voice_use_speaker_boost: z.boolean().describe("Whether to use speaker boost for the voice").default(false),
-  tts_model: z.enum([
-    "eleven_monolingual_v1",
-    "eleven_multilingual_v1",
-    "eleven_multilingual_v2",
-    "eleven_turbo_v2",
-    "eleven_turbo_v2_5",
-    "eleven_flash_v2_5",
-    "eleven_flash_v2",
-    "eleven_v3"
-  ]).describe("ElevenLabs model to use").default("eleven_turbo_v2"),
-  tts_inactivity_timeout: z.number().int().describe("Inactivity timeout in seconds for the websocket connection").default(300),
-  tts_enable_ssml_parsing: z.boolean().describe("Enable SSML parsing for input text").default(true),
-  tts_streaming_latency: z.number().int().describe(
-    "Optimize for streaming latency, 0 to disable, 4 for max latency optimizations (deprecated)"
-  ).default(3),
-  tts_auto_mode: z.boolean().describe(
-    "Reduces latency by disabling chunk schedule and buffers. Sentence tokenizer will be used to synthesize one sentence at a time"
-  ).default(true),
-  tts_encoding: z.enum([
-    "mp3_22050_32",
-    "mp3_24000_48",
-    "mp3_44100",
-    "mp3_44100_32",
-    "mp3_44100_64",
-    "mp3_44100_96",
-    "mp3_44100_128",
-    "mp3_44100_192",
-    "opus_48000_32",
-    "opus_48000_64",
-    "opus_48000_96",
-    "opus_48000_128",
-    "opus_48000_192",
-    "pcm_8000",
-    "pcm_16000",
-    "pcm_22050",
-    "pcm_24000",
-    "pcm_32000",
-    "pcm_44100",
-    "pcm_48000"
-  ]).describe("Audio encoding format for TTS output").default("mp3_44100_128"),
-  tts_chunk_length_schedule: z.array(z.number().int()).describe("Schedule for chunk lengths, ranging 50...500").default([120, 160, 250, 290]),
-  tts_language: z.string().describe("Language code for the TTS model").default("en")
-});
-
-// src/call-control/voice-agent-config.ts
-var TURN_DETECTION_MODES = /* @__PURE__ */ new Set(["model", "stt", "vad"]);
-var TURN_DETECTOR_MIN_SILENCE_DURATION = 0.25;
-function getTurnDetectionSettingsIssue(settings) {
-  if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
-    return {
-      message: "Voice agent settings must be an object",
-      path: [],
-      type: "type"
-    };
-  }
-  const values = settings;
-  const mode = values.session_turn_detection;
-  if (mode !== void 0 && (typeof mode !== "string" || !TURN_DETECTION_MODES.has(mode))) {
-    return {
-      message: "Turn detection must use model, STT, or VAD mode",
-      path: ["session_turn_detection"],
-      type: "type"
-    };
-  }
-  const minSilence = values.vad_min_silence_duration;
-  if (minSilence !== void 0 && (typeof minSilence !== "number" || !Number.isFinite(minSilence))) {
-    return {
-      message: "The minimum VAD silence duration must be a finite number",
-      path: ["vad_min_silence_duration"],
-      type: "type"
-    };
-  }
-  if (minSilence !== void 0 && minSilence < TURN_DETECTOR_MIN_SILENCE_DURATION && (mode === void 0 || mode === "model")) {
-    return {
-      message: "Audio turn detection requires at least 0.25 seconds of VAD silence",
-      path: ["vad_min_silence_duration"],
-      type: "range"
-    };
-  }
-  return void 0;
-}
-var voiceAgentConfigSchema = configSchema.superRefine((settings, context) => {
-  const issue = getTurnDetectionSettingsIssue(settings);
-  if (issue) context.addIssue({ code: "custom", message: issue.message, path: issue.path });
-});
-function validateVoiceAgentTurnDetectionSettings(settings) {
-  const issue = getTurnDetectionSettingsIssue(settings);
-  if (!issue) return;
-  if (issue.type === "range") throw new RangeError(issue.message);
-  throw new TypeError(issue.message);
-}
-
-// src/call-control/types.ts
-var MediaEncryption = { DISABLE: 0, ALLOW: 1, REQUIRE: 2 };
-var Transport = { AUTO: 0, UDP: 1, TCP: 2, TLS: 3 };
-var IncludeHeaders = { NO_HEADERS: 0, X_HEADERS: 1, ALL_HEADERS: 2 };
-var CallSignalType = /* @__PURE__ */ ((CallSignalType2) => {
-  CallSignalType2["Transfer"] = "transfer";
-  CallSignalType2["Reload"] = "reload";
-  CallSignalType2["HangUp"] = "hangup";
-  CallSignalType2["Freeze"] = "freeze";
-  CallSignalType2["Unfreeze"] = "unfreeze";
-  CallSignalType2["SendMessage"] = "send-message";
-  CallSignalType2["UpdateSettings"] = "update-settings";
-  CallSignalType2["Steer"] = "steer";
-  return CallSignalType2;
-})(CallSignalType || {});
-var CallDataTopic = /* @__PURE__ */ ((CallDataTopic2) => {
-  CallDataTopic2["AgentSignal"] = "agent-signal";
-  return CallDataTopic2;
-})(CallDataTopic || {});
-var _defaults = voiceAgentConfigSchema.parse({});
-var _defaultsExcluded = [
-  // Produces errors if set to null, complicated dynamic logic of setter
-  "vad_deactivation_threshold",
-  // Deepgram Flux-only fields, not used anywhere now
-  "stt_eager_eot_threshold",
-  "stt_eot_timeout_ms",
-  "stt_eot_threshold"
-];
-var voiceAgentDefaultConfig = Object.fromEntries(
-  Object.entries(_defaults).filter(
-    ([field]) => !_defaultsExcluded.includes(field)
-  )
-);
-
-// src/call-control/call-details/noop-storage.ts
-var NoopCallDetailsStorage = class {
-  async get(_) {
-    return null;
-  }
-  async list() {
-    return [];
-  }
-  async delete(_) {
-    return;
-  }
-};
-
-// src/call-control/sip.ts
-import {
-  RoomAgentDispatch,
-  RoomConfiguration,
-  SipClient
-} from "livekit-server-sdk";
-
-// src/call-control/sip-setup-lock.ts
-import { randomUUID } from "node:crypto";
-import { RoomServiceClient } from "livekit-server-sdk";
-
-// src/call-control/utils.ts
-import { createHash } from "node:crypto";
-var CallControlError = class extends Error {
-  constructor(message, cause) {
-    super(message, { cause });
-    this.name = "CallControlError";
-  }
-};
-function getLiveKitConnectionOptions(options = {}) {
-  const {
-    url = process.env.LIVEKIT_URL,
-    key = process.env.LIVEKIT_API_KEY,
-    secret = process.env.LIVEKIT_API_SECRET
-  } = options;
-  const finalOptions = { url, key, secret };
-  Object.entries(finalOptions).forEach(([key2, value]) => {
-    if (!value) throw new CallControlError(`LiveKit ${key2} not set`);
-  });
-  return finalOptions;
-}
-function getCallIdFromRoomName(roomName) {
-  return roomName.split("_").pop() ?? "";
-}
-function toTitleCase(str) {
-  return str.toLowerCase().replace(new RegExp("\\b\\p{L}", "gu"), (char) => char.toUpperCase());
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.keys(value).sort().map((k) => [k, sortKeys(value[k])])
-    );
-  }
-  return value;
-}
-function computeObjectHash(value, algo = "sha256") {
-  return createHash(algo).update(JSON.stringify(sortKeys(value)) ?? "").digest("hex");
-}
-function anyOf(...items) {
-  return [...items].some(Boolean);
-}
-
-// src/call-control/sip-setup-lock.ts
-var LOCK_ROOM_NAME = "__sip_setup_lock__";
-var LOCK_ROOM_EMPTY_TIMEOUT_S = 60;
-var LOCK_ACQUIRE_TIMEOUT_MS = 3e4;
-var LOCK_RETRY_INTERVAL_MS = 500;
-var LOCK_REQUEST_TIMEOUT_S = 5;
-function createSipSetupLock(url, key, secret, logger = console) {
-  const roomService = new RoomServiceClient(url, key, secret, {
-    requestTimeout: LOCK_REQUEST_TIMEOUT_S
-  });
-  let lockId;
-  return {
-    async acquire() {
-      lockId = randomUUID();
-      const startTime = Date.now();
-      while (Date.now() - startTime < LOCK_ACQUIRE_TIMEOUT_MS) {
-        try {
-          const room = await roomService.createRoom({
-            name: LOCK_ROOM_NAME,
-            emptyTimeout: LOCK_ROOM_EMPTY_TIMEOUT_S,
-            agents: [],
-            metadata: lockId
-          });
-          if (room.metadata === lockId) {
-            logger.info("SIP setup lock acquired");
-            return;
-          }
-          logger.info("SIP setup lock held by another instance, waiting...", {
-            holder: room.metadata
-          });
-        } catch (err) {
-          logger.warn("SIP setup lock acquire attempt failed, retrying...", { err });
-        }
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
-      }
-      lockId = void 0;
-      throw new CallControlError(
-        `Failed to acquire SIP setup lock within ${LOCK_ACQUIRE_TIMEOUT_MS}ms`
-      );
-    },
-    async release() {
-      try {
-        await roomService.deleteRoom(LOCK_ROOM_NAME);
-        logger.info("SIP setup lock released");
-      } catch (err) {
-        if (err instanceof Error && err.message.includes("not found")) {
-          logger.debug("SIP setup lock already released");
-          return;
-        }
-        logger.error("Failed to release SIP setup lock", { err });
-        throw err;
-      } finally {
-        lockId = void 0;
-      }
-    }
-  };
-}
-
-// src/call-control/sip.ts
-var DEFAULT_TRUNK_CONFIG = {
-  mediaEncryption: MediaEncryption.ALLOW,
-  includeHeaders: IncludeHeaders.ALL_HEADERS
-};
-var SipManager = class {
-  agentName;
-  client;
-  lock;
-  options;
-  trunksConfigHash;
-  logger;
-  constructor(options, logger = console, debugMode = Boolean(process.env.SIP_DEBUG)) {
-    if (debugMode) {
-      populateOptionsFromEnv(options);
-    }
-    const { agentName, livekit = {} } = options;
-    this.agentName = agentName;
-    this.options = options;
-    this.validateOptions();
-    this.trunksConfigHash = computeObjectHash(options.trunks);
-    const { url, key, secret } = getLiveKitConnectionOptions(livekit);
-    this.client = new SipClient(url, key, secret);
-    this.logger = logger;
-    this.lock = createSipSetupLock(url, key, secret, this.logger);
-  }
-  get trunksConfig() {
-    return this.options.trunks;
-  }
-  get trunksConfigDefaultMeta() {
-    return {
-      ["agentName" /* AgentName */]: this.agentName,
-      ["_configHash" /* ConfigHash */]: this.trunksConfigHash
-    };
-  }
-  validateOptions() {
-    const { in: inbound, out: outbound, transfer } = this.trunksConfig ?? {};
-    if (!anyOf(inbound, outbound, transfer)) {
-      throw new SipError("No trunk configured");
-    }
-    if (inbound && !(inbound.numbers ?? []).filter(Boolean).length) {
-      throw new SipError("No phone numbers set for the inbound trunk");
-    }
-    if (transfer && !transfer.server) {
-      throw new SipError("No SIP server set for transfer trunk");
-    }
-    if (outbound && !outbound.server) {
-      throw new SipError("No SIP server set for outbound trunk");
-    }
-    if (this.options.transferRequired) {
-      if (!anyOf(outbound, transfer))
-        throw new SipError("No configuration for the transfer trunk");
-    }
-  }
-  async setup(withCleanup = true) {
-    const agentName = this.agentName;
-    let resources = { agentName };
-    let inboundTrunk, transferTrunk, outboundTrunk, dispatchRule, error;
-    this.logger.info("SIP resources setup started...", { agentName });
-    await this.lock.acquire();
-    try {
-      const existing = await this.getAllResources();
-      if (this.isResourceSetComplete(existing)) {
-        const ownedInbound = existing.inboundTrunks.find(this.isOwnResource);
-        const ownedOutbound = existing.outboundTrunks.find(
-          (trunk) => this.isOwnResource(trunk) && getMetaValue(trunk.metadata, "trunkType" /* Type */) === "outbound"
-        );
-        const ownedTransfer = existing.outboundTrunks.find(
-          (trunk) => this.isOwnResource(trunk) && getMetaValue(trunk.metadata, "trunkType" /* Type */) === "transfer"
-        );
-        const storedHash = getMetaValue(
-          (ownedInbound ?? ownedTransfer ?? ownedOutbound)?.metadata,
-          "_configHash" /* ConfigHash */
-        );
-        if (storedHash === this.trunksConfigHash) {
-          this.logger.info("SIP resources unchanged, reusing existing.", {
-            agentName,
-            ["_configHash" /* ConfigHash */]: storedHash
-          });
-          inboundTrunk = ownedInbound;
-          transferTrunk = ownedTransfer;
-          outboundTrunk = ownedOutbound;
-          dispatchRule = existing.rules.find(this.isOwnResource);
-        }
-      }
-      if (!anyOf(inboundTrunk, transferTrunk, outboundTrunk)) {
-        if (withCleanup) {
-          await this.cleanup(existing);
-        }
-        if (this.trunksConfig.in) {
-          await this.resolveNumberConflicts(existing);
-          inboundTrunk = await this.createInboundTrunk();
-          if (inboundTrunk) {
-            dispatchRule = await this.createDispatchRule(inboundTrunk.sipTrunkId);
-          }
-        }
-        if (this.trunksConfig.transfer) {
-          transferTrunk = await this.createOutboundTrunk("transfer");
-        }
-        if (this.trunksConfig.out) {
-          outboundTrunk = await this.createOutboundTrunk("outbound");
-        }
-      }
-      resources = { ...resources, inboundTrunk, transferTrunk, outboundTrunk, dispatchRule };
-    } catch (_error) {
-      error = _error;
-    } finally {
-      await this.lock.release();
-    }
-    if (error) {
-      this.logger.error("SIP resources setup failed!", { error });
-      throw new SipError("Resources setup error", error);
-    }
-    this.logger.info("SIP resources setup completed.", { resources });
-    return resources;
-  }
-  async getTransferTrunkId() {
-    return (await this.client.listSipOutboundTrunk()).find(
-      (trunk) => this.isOwnResource(trunk) && getMetaValue(trunk.metadata, "trunkType" /* Type */) === "transfer"
-    )?.sipTrunkId;
-  }
-  async createInboundTrunk() {
-    const agentName = this.agentName;
-    const config = this.trunksConfig.in;
-    const metadata = {
-      ...config.metadata ?? {},
-      ...this.trunksConfigDefaultMeta
-    };
-    const options = {
-      ...DEFAULT_TRUNK_CONFIG,
-      ...config,
-      metadata: JSON.stringify(metadata)
-    };
-    this.logger.info("Creating inbound trunk...", {
-      agentName,
-      numbers: config.numbers,
-      options
-    });
-    if (config.allowedAddresses) {
-      options.allowedAddresses = config.allowedAddresses;
-    }
-    const trunk = await this.client.createSipInboundTrunk(agentName, config.numbers, options);
-    this.logger.info("Inbound trunk created.", { agentName, ...trunk });
-    return trunk;
-  }
-  async createOutboundTrunk(type = "transfer") {
-    const agentName = this.agentName;
-    const config = type === "transfer" ? this.trunksConfig.transfer : this.trunksConfig.out;
-    const metadata = {
-      ...config.metadata ?? {},
-      ...this.trunksConfigDefaultMeta,
-      ["trunkType" /* Type */]: type
-    };
-    const { numbers = ["*"], server, transport = Transport.TCP } = config;
-    const options = {
-      ...DEFAULT_TRUNK_CONFIG,
-      ...config,
-      transport,
-      metadata: JSON.stringify(metadata)
-    };
-    this.logger.info(`Creating ${type} trunk...`, { agentName, numbers, server, options });
-    const trunk = await this.client.createSipOutboundTrunk(
-      `${toTitleCase(type)} trunk for ${agentName}`,
-      server,
-      numbers,
-      options
-    );
-    this.logger.info(`${toTitleCase(type)} trunk created.`, { agentName, ...trunk });
-    return trunk;
-  }
-  async createDispatchRule(trunkId, type = "individual") {
-    const agentName = this.agentName;
-    const ruleConfig = {
-      type,
-      roomPrefix: this.options.roomPrefix
-    };
-    const attributes = {
-      ...this.trunksConfig.in?.metadata ?? {},
-      ...this.trunksConfigDefaultMeta
-    };
-    const metadata = JSON.stringify(attributes);
-    this.logger.info("Creating dispatch rule...", {
-      agentName,
-      inboundTrunkId: trunkId,
-      attributes,
-      ruleConfig
-    });
-    const roomAgentDispatch = new RoomAgentDispatch({
-      // IMPORTANT!
-      // agentName MUST be empty string for jobs to be dispatched to universal voice agent
-      agentName: "",
-      metadata
-    });
-    const options = {
-      trunkIds: [trunkId],
-      metadata,
-      attributes,
-      roomConfig: new RoomConfiguration({ agents: [roomAgentDispatch] })
-    };
-    const rule = await this.client.createSipDispatchRule(ruleConfig, options);
-    this.logger.info("Dispatch rule created.", { agentName, ...rule });
-    return rule;
-  }
-  async resolveNumberConflicts(preloaded) {
-    const numbers = this.trunksConfig.in.numbers;
-    const all = preloaded ?? await this.getAllResources();
-    const conflicting = all.inboundTrunks.filter(
-      (trunk) => !this.isOwnResource(trunk) && trunk.numbers?.some((n) => numbers.includes(n))
-    );
-    if (conflicting.length === 0) return;
-    const conflictingTrunkIds = new Set(conflicting.map(({ sipTrunkId: id }) => id));
-    const orphanedRules = all.rules.filter(
-      (rule) => rule.trunkIds?.some((id) => conflictingTrunkIds.has(id))
-    );
-    for (const rule of orphanedRules) {
-      this.logger.warn("Deleting dispatch rule associated with conflicting trunk", {
-        ruleId: rule.sipDispatchRuleId,
-        owner: getMetaValue(rule.metadata, "agentName" /* AgentName */)
-      });
-      try {
-        await this.deleteDispatchRule(rule.sipDispatchRuleId);
-      } catch (err) {
-        this.logger.error("Failed to delete conflicting dispatch rule", {
-          ruleId: rule.sipDispatchRuleId,
-          err
-        });
-        throw new SipError("Cannot delete dispatch rule", err);
-      }
-    }
-    for (const trunk of conflicting) {
-      this.logger.warn("Deleting inbound trunk with conflicting phone numbers", {
-        trunkId: trunk.sipTrunkId,
-        owner: getMetaValue(trunk.metadata, "agentName" /* AgentName */),
-        conflictingNumbers: trunk.numbers?.filter((n) => numbers.includes(n))
-      });
-      try {
-        await this.deleteTrunk(trunk.sipTrunkId);
-      } catch (err) {
-        this.logger.error("Failed to delete conflicting inbound trunk", {
-          trunkId: trunk.sipTrunkId,
-          err
-        });
-        throw new SipError("Cannot delete trunk", err);
-      }
-    }
-  }
-  isOwnResource = (resource) => {
-    return getMetaValue(resource.metadata, "agentName" /* AgentName */) === this.agentName;
-  };
-  isResourceSetComplete(resources) {
-    const ownedInbound = resources.inboundTrunks.filter(this.isOwnResource);
-    const ownedOutbound = resources.outboundTrunks.filter(this.isOwnResource);
-    const ownedRules = resources.rules.filter(this.isOwnResource);
-    if (this.trunksConfig.in && (ownedInbound.length === 0 || ownedRules.length === 0)) {
-      return false;
-    }
-    const neededOutbound = (this.trunksConfig.transfer ? 1 : 0) + (this.trunksConfig.out ? 1 : 0);
-    if (neededOutbound > 0 && ownedOutbound.length < neededOutbound) return false;
-    return true;
-  }
-  async cleanup(preloaded) {
-    await this.deleteAllResources(5, 500, preloaded);
-  }
-  async deleteAllResources(maxAttempts = 5, retryInterval = 500, preloaded) {
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const all2 = attempt === 1 && preloaded ? preloaded : await this.getAllResources();
-      const rules = all2.rules.filter(this.isOwnResource);
-      const inboundTrunks = all2.inboundTrunks.filter(this.isOwnResource);
-      const outboundTrunks = all2.outboundTrunks.filter(this.isOwnResource);
-      const trunkIds = /* @__PURE__ */ new Set([
-        ...inboundTrunks.map((t) => t.sipTrunkId),
-        ...outboundTrunks.map((t) => t.sipTrunkId)
-      ]);
-      this.logger.info("Cleanup: resources found", {
-        attempt,
-        maxAttempts,
-        dispatchRules: rules.length,
-        inboundTrunks: inboundTrunks.length,
-        outboundTrunks: outboundTrunks.length,
-        uniqueTrunks: trunkIds.size
-      });
-      if (rules.length === 0 && trunkIds.size === 0) {
-        this.logger.info("Cleanup: nothing to delete");
-        return;
-      }
-      for (const rule of rules) {
-        this.logger.info("Cleanup: deleting dispatch rule", { rule });
-        try {
-          await this.deleteDispatchRule(rule.sipDispatchRuleId);
-        } catch (err) {
-          this.logger.error("Cleanup: dispatch rule deletion failed (will retry)", {
-            ruleId: rule.sipDispatchRuleId,
-            err
-          });
-        }
-      }
-      for (const trunk of inboundTrunks) {
-        this.logger.info("Cleanup: deleting inbound trunk", { trunk });
-        try {
-          await this.deleteTrunk(trunk.sipTrunkId);
-        } catch (err) {
-          this.logger.error("Cleanup: inbound trunk deletion failed (will retry)", {
-            trunkId: trunk.sipTrunkId,
-            err
-          });
-        }
-      }
-      for (const trunk of outboundTrunks) {
-        this.logger.info("Cleanup: deleting outbound trunk", { trunk });
-        try {
-          await this.deleteTrunk(trunk.sipTrunkId);
-        } catch (err) {
-          this.logger.error("Cleanup: outbound trunk deletion failed (will retry)", {
-            trunkId: trunk.sipTrunkId,
-            err
-          });
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, retryInterval));
-    }
-    const all = await this.getAllResources();
-    const remainingRules = all.rules.filter(this.isOwnResource);
-    const remainingInbound = all.inboundTrunks.filter(this.isOwnResource);
-    const remainingOutbound = all.outboundTrunks.filter(this.isOwnResource);
-    const remainingTrunkIds = /* @__PURE__ */ new Set([
-      ...remainingInbound.map(({ sipTrunkId }) => sipTrunkId),
-      ...remainingOutbound.map(({ sipTrunkId }) => sipTrunkId)
-    ]);
-    this.logger.error("Cleanup: resources still remain after retries", {
-      dispatchRules: remainingRules.length,
-      inboundTrunks: remainingInbound.length,
-      outboundTrunks: remainingOutbound.length,
-      uniqueTrunks: remainingTrunkIds.size
-    });
-    throw new SipError(
-      `Failed to delete all SIP trunks/dispatch rules after ${maxAttempts} attempts`
-    );
-  }
-  async getAllResources() {
-    const [rules, inboundTrunks, outboundTrunks] = await Promise.all([
-      this.client.listSipDispatchRule(),
-      this.client.listSipInboundTrunk(),
-      this.client.listSipOutboundTrunk()
-    ]);
-    return { rules, inboundTrunks, outboundTrunks };
-  }
-  async deleteTrunk(trunkId) {
-    try {
-      await this.client.deleteSipTrunk(trunkId);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("not found")) {
-        this.logger.info("Trunk was deleted previously", { trunkId });
-        return;
-      }
-      this.logger.error("Failed to delete trunk", { trunkId, err });
-      throw new SipError("Failed to delete trunk", err);
-    }
-    this.logger.info("Trunk deleted", { trunkId });
-  }
-  async deleteDispatchRule(ruleId) {
-    try {
-      await this.client.deleteSipDispatchRule(ruleId);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("not found")) {
-        this.logger.info("Dispatch rule was deleted previously", { ruleId });
-        return;
-      }
-      this.logger.error("Failed to delete dispatch rule", { ruleId, err });
-      throw new SipError("Failed to delete dispatch rule", err);
-    }
-    this.logger.info("Dispatch rule deleted", { ruleId });
-  }
-};
-function getMetaValue(metadata, key) {
-  if (!metadata) {
-    return void 0;
-  }
-  try {
-    const meta = JSON.parse(metadata);
-    return meta[key];
-  } catch {
-    return void 0;
-  }
-}
-var SipError = class extends CallControlError {
-  constructor(message, cause) {
-    super(message, cause);
-    this.name = "SipError";
-  }
-};
-function populateOptionsFromEnv(options = {}, parse = JSON.parse) {
-  const {
-    SIP_ROOM_PREFIX: roomPrefix,
-    SIP_INBOUND_NUMBERS: inboundNumbers,
-    SIP_INBOUND_ALLOWED_NUMBERS: inboundAllowedNumbers,
-    SIP_INBOUND_ALLOWED_ADDRESSES: inboundAllowedAddresses,
-    SIP_INBOUND_AUTH_USERNAME: inboundAuthUsername,
-    SIP_INBOUND_AUTH_PASSWORD: inboundAuthPassword,
-    SIP_INBOUND_METADATA: inboundMetadata,
-    SIP_INBOUND_MEDIA_ENCRYPTION: inboundMediaEncryption,
-    SIP_INBOUND_HEADERS: inboundHeaders,
-    SIP_INBOUND_HEADERS_TO_ATTRS: inboundHeadersToAttrs,
-    SIP_INBOUND_ATTRS_TO_HEADERS: inboundAttrsToHeaders
-  } = process.env;
-  if (roomPrefix && !options.roomPrefix) {
-    options.roomPrefix = roomPrefix;
-  }
-  const inbound = options.trunks?.in ?? {};
-  if (inboundNumbers) inbound.numbers = parse(inboundNumbers);
-  if (inboundAllowedNumbers) inbound.allowedNumbers = parse(inboundAllowedNumbers);
-  if (inboundAllowedAddresses)
-    inbound.allowedAddresses = parse(inboundAllowedAddresses);
-  if (inboundAuthUsername) inbound.authUsername = inboundAuthUsername;
-  if (inboundAuthPassword) inbound.authPassword = inboundAuthPassword;
-  if (inboundMetadata) inbound.metadata = parse(inboundMetadata);
-  if (inboundMediaEncryption)
-    inbound.mediaEncryption = Number(inboundMediaEncryption);
-  if (inboundHeaders) inbound.headers = parse(inboundHeaders);
-  if (inboundHeadersToAttrs)
-    inbound.headersToAttributes = parse(inboundHeadersToAttrs);
-  if (inboundAttrsToHeaders)
-    inbound.attributesToHeaders = parse(inboundAttrsToHeaders);
-  if (Object.keys(inbound).length) {
-    options.trunks = { ...options.trunks ?? {}, in: inbound };
-  }
-  return options;
-}
-
-// src/call-control/call-control.ts
-import { DataPacket_Kind, RoomServiceClient as RoomServiceClient2 } from "livekit-server-sdk";
-var DEFAULT_ROOM_PREFIX = "call";
-var STALE_FREEZE_MS = 30 * 60 * 1e3;
-var CallControl = class {
-  roomService;
-  livekit;
-  /** One SIP manager per agent that called `setUpSip`. */
-  sips = /* @__PURE__ */ new Map();
-  storage;
-  conversationalTracer;
-  eventTracer;
-  freezeStarts = /* @__PURE__ */ new Map();
-  logger;
-  constructor({ livekit = {}, storage, conversationalTracer, eventTracer }, logger = console) {
-    const { url, key, secret } = getLiveKitConnectionOptions(livekit);
-    this.roomService = new RoomServiceClient2(url, key, secret);
-    this.livekit = livekit;
-    this.storage = storage ?? new NoopCallDetailsStorage();
-    this.conversationalTracer = conversationalTracer;
-    this.eventTracer = eventTracer;
-    this.logger = logger;
-  }
-  async trace(eventName, callId, content) {
-    if (!this.conversationalTracer) return;
-    try {
-      this.conversationalTracer.addConversationalTrace({
-        conversationId: callId,
-        eventName,
-        role: "agent",
-        medium: "phone",
-        content,
-        createdAt: Date.now()
-      });
-      await this.conversationalTracer.flush();
-    } catch (err) {
-      this.logger.error("Failed to write conversational trace", { err });
-    }
-  }
-  /**
-   * Safe on every signal that releases a freeze: a no-op when the call is not frozen, so an
-   * unfreeze straight after a reload counts once.
-   */
-  endFreeze(callId, endedBy) {
-    const startedAt = this.freezeStarts.get(callId);
-    if (startedAt === void 0) return;
-    this.freezeStarts.delete(callId);
-    this.eventTracer?.emit({
-      event: "workflow.freeze.outlier",
-      attributes: {
-        conversationId: callId,
-        durationMs: Date.now() - startedAt,
-        endedBy
-      }
-    });
-  }
-  dropStaleFreezes() {
-    const oldest = Date.now() - STALE_FREEZE_MS;
-    for (const [callId, startedAt] of this.freezeStarts) {
-      if (startedAt < oldest) this.freezeStarts.delete(callId);
-    }
-  }
-  async sendSignalToRoom(room, signal, packetType = DataPacket_Kind.RELIABLE, topic = "agent-signal" /* AgentSignal */) {
-    const data = Buffer.from(JSON.stringify(signal));
-    await this.roomService.sendData(room.name, data, packetType, { topic });
-  }
-  async setVoiceSettings(callId, settings) {
-    validateVoiceAgentTurnDetectionSettings(settings);
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "update-settings" /* UpdateSettings */,
-      payload: settings
-    });
-    this.logger.info("Settings update request sent", { settings });
-  }
-  /**
-   * Build the SIP resources for one agent. One connector serves every agent of the process, so
-   * each agent brings its own trunk configuration, usually from `onServiceStartup`.
-   */
-  async setUpSip(agentName, sip) {
-    const options = {
-      ...sip,
-      roomPrefix: sip.roomPrefix ?? DEFAULT_ROOM_PREFIX,
-      livekit: this.livekit,
-      agentName
-    };
-    const sipManager = new SipManager(options, this.logger);
-    await this.waitForHealth();
-    await sipManager.setup();
-    this.sips.set(agentName, sipManager);
-  }
-  async freeze(callId, muteBackgroundAudio = true) {
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "freeze" /* Freeze */,
-      payload: { mute_background_audio: muteBackgroundAudio }
-    });
-    this.dropStaleFreezes();
-    if (!this.freezeStarts.has(callId)) {
-      this.freezeStarts.set(callId, Date.now());
-    }
-  }
-  async unfreeze(callId) {
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "unfreeze" /* Unfreeze */
-    });
-    this.endFreeze(callId, "unfreeze");
-  }
-  async steer(callId, payload) {
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "steer" /* Steer */,
-      payload
-    });
-    if (payload.respond) {
-      this.endFreeze(callId, "steer");
-    }
-  }
-  async addMessage(callId, message) {
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "send-message" /* SendMessage */,
-      payload: { content: message.text, role: message.sender }
-    });
-  }
-  async reload(callId) {
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "reload" /* Reload */
-    });
-    this.endFreeze(callId, "reload");
-  }
-  async transfer(agentName, destination, callId, headers, reason = "escalation", disclaimer, waitBefore = 500) {
-    await this.trace("transfer-requested", callId, destination);
-    this.eventTracer?.emit({
-      event: "agent.escalation.requested",
-      attributes: {
-        conversationId: callId,
-        agentId: agentName,
-        escalationReason: reason,
-        channel: "phone"
-      }
-    });
-    if (waitBefore > 0) {
-      await new Promise((resolve) => setTimeout(resolve, waitBefore));
-    }
-    const room = await this.getRoomByCallId(callId);
-    const sipTrunkId = await this.sips.get(agentName)?.getTransferTrunkId();
-    if (!sipTrunkId) {
-      this.logger.warn(
-        "Transfer requested without SIP trunk configured: proceeding with empty `sipTrunkId`",
-        { agentName, callId, destination, reason }
-      );
-    }
-    const request = {
-      to: destination,
-      ...sipTrunkId ? { sipTrunkId } : {},
-      ...headers ? { headers } : {},
-      ...disclaimer ? { disclaimer } : {},
-      reason,
-      playDialtone: true
-    };
-    this.logger.info("Transfer requested", { request });
-    await this.sendSignalToRoom(room, { signal: "transfer" /* Transfer */, payload: request });
-    this.endFreeze(callId, "transfer");
-  }
-  async hangup(callId, waitBefore = 500) {
-    await this.trace("hangup-requested", callId, "hangup");
-    if (waitBefore > 0) {
-      await new Promise((resolve) => setTimeout(resolve, waitBefore));
-    }
-    await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
-      signal: "hangup" /* HangUp */
-    });
-    this.endFreeze(callId, "hangup");
-  }
-  async getCallDetails(callId) {
-    return await this.storage.get(callId);
-  }
-  async healthCheck() {
-    try {
-      await this.roomService.listRooms();
-      return true;
-    } catch (err) {
-      console.error("LiveKit health-check error", { err });
-      return false;
-    }
-  }
-  async waitForHealth(retries = 5, baseDelayMs = 1e3) {
-    let isHealthy = false;
-    for (let attempt = 0; attempt < retries; attempt++) {
-      this.logger.debug("Checking LiveKit connection...", { attempt: attempt + 1, retries });
-      isHealthy = await this.healthCheck();
-      if (isHealthy) {
-        break;
-      }
-      if (attempt === retries - 1) {
-        throw new CallControlError(`Failed to connect to LiveKit after ${retries} attempts`);
-      }
-      const delayMs = baseDelayMs * Math.pow(2, attempt);
-      this.logger.error("Failed to connect to LiveKit, retrying...", { delayMs });
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-    return isHealthy;
-  }
-  async getRoomByCallId(callId) {
-    const roomsList = await this.roomService.listRooms();
-    const room = roomsList.find(({ name }) => getCallIdFromRoomName(name) === callId);
-    if (!room) {
-      const err = new CallControlError(`Room not found for call [${callId}]`);
-      this.logger.error("Room not found", { callId, err });
-      throw err;
-    }
-    return room;
-  }
-};
-export {
-  CallControl,
-  CallControlError,
-  CallDataTopic,
-  CallSignalType,
-  DEFAULT_ROOM_PREFIX,
-  IncludeHeaders,
-  MediaEncryption,
-  NoopCallDetailsStorage,
-  Room,
-  SipDispatchRule,
-  SipError,
-  SipInboundTrunk,
-  SipManager,
-  SipOutboundTrunk,
-  Transport,
-  CallControl as default,
-  validateVoiceAgentTurnDetectionSettings,
-  voiceAgentConfigSchema,
-  voiceAgentDefaultConfig
-};