supafone-labs 0.3.0

package/dist/cjs/index.js

@@ -0,0 +1,761 @@
+"use strict";
+/**
+ * Supafone Labs — the agent framework behind Supafone.
+ *
+ * A dependency-free TypeScript client for creating hosted Supafone agents
+ * through the Supafone API, including managed phone numbers, voices, stages,
+ * tools, recordings, transcripts, widgets, and Supafone Pro watcher. It also
+ * includes the Labs cloud sidecar oracle, hosted TTS/STT, live multilingual
+ * transcription, telemetry, agent builder, and objective-driven optimizer.
+ *
+ * Works in Node 18+ (native fetch/WebSocket) and the browser.
+ *
+ *   npm i @supafonesupafone-labs
+ *
+ *   import { Supafone } from "@supafonesupafone-labs";
+ *   const supafone = new Supafone({ apiKey: process.env.SUPAFONE_API_KEY! });
+ *   const agent = await supafone.labs.agents.createInboundWithNumber({
+ *     agentKey: "northline-intake",
+ *     name: "Northline intake",
+ *     number: { search: { areaCode: "415" } },
+ *   });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Supafone = exports.SupafoneLabs = exports.SupafoneLabsError = void 0;
+class SupafoneLabsError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "SupafoneLabsError";
+    }
+}
+exports.SupafoneLabsError = SupafoneLabsError;
+const DEFAULT_BASE = "https://api.labs.supafone.ai";
+const DEFAULT_SUPAFONE_API_BASE = "https://api.supafone.ai";
+const COACH_SYSTEM = "You are the coaching core of a second mind for a live voice agent. Read the " +
+    "conversation and return ONE short, silent directive the agent reads but never " +
+    "speaks aloud — a correction or nudge, phrased imperatively. If nothing needs " +
+    "correcting, return an empty string.";
+class SupafoneLabs {
+    baseUrl;
+    supafoneApiBaseUrl;
+    apiKey;
+    supafoneApiKey;
+    timeoutMs;
+    sessionToken;
+    labs;
+    builder;
+    qa;
+    optimizer;
+    constructor(opts) {
+        if (!opts?.apiKey)
+            throw new SupafoneLabsError("apiKey is required");
+        this.apiKey = opts.apiKey;
+        this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
+        this.supafoneApiKey = opts.supafoneApiKey ?? opts.apiKey;
+        this.supafoneApiBaseUrl = (opts.supafoneApiBaseUrl ?? DEFAULT_SUPAFONE_API_BASE).replace(/\/$/, "");
+        this.timeoutMs = opts.timeoutMs ?? 30_000;
+        this.sessionToken = opts.sessionToken;
+        this.labs = new LabsNamespace(this);
+        this.builder = new BuilderNamespace(this);
+        this.qa = new QANamespace(this);
+        this.optimizer = new OptimizerNamespace(this);
+    }
+    /** True once login() (or a passed sessionToken) is in effect. */
+    get isLoggedIn() {
+        return !!this.sessionToken;
+    }
+    /**
+     * Exchange email/password for a console session. Required by the builder.*
+     * methods and qa.run (which are account/session-scoped, not key-scoped).
+     */
+    async login(email, password) {
+        const d = await this.request("POST", "/v1/auth/login", { email, password });
+        if (!d.token)
+            throw new SupafoneLabsError("Login succeeded but returned no token");
+        this.sessionToken = d.token;
+    }
+    /** @internal Authenticated JSON request. `useSession` prefers the login token. */
+    async request(method, path, body, useSession = false) {
+        const token = useSession && this.sessionToken ? this.sessionToken : this.apiKey;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(this.baseUrl + path, {
+                method,
+                signal: ctrl.signal,
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+            const text = await res.text();
+            const parsed = text ? safeJson(text) : {};
+            if (!res.ok) {
+                const detail = parsed?.detail ?? text ?? `HTTP ${res.status}`;
+                throw new SupafoneLabsError(`${method} ${path}: ${detail}`, res.status, parsed);
+            }
+            return parsed;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** @internal Authenticated JSON request to the Supafone app API (`/api/v1supafone-labs/*`). */
+    async requestSupafoneApi(method, path, body) {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(this.supafoneApiBaseUrl + path, {
+                method,
+                signal: ctrl.signal,
+                headers: { Authorization: `Bearer ${this.supafoneApiKey}`, "Content-Type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+            const text = await res.text();
+            const parsed = text ? safeJson(text) : {};
+            if (!res.ok) {
+                const detail = parsed?.detail ?? text ?? `HTTP ${res.status}`;
+                throw new SupafoneLabsError(`${method} ${path}: ${detail}`, res.status, parsed);
+            }
+            return parsed;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Raw oracle completion — full control over messages and model. */
+    async oracle(req) {
+        return this.request("POST", "/v1/oracle/complete", {
+            messages: req.messages,
+            model: req.model ?? "supafone-labs-oracle",
+            max_tokens: req.maxTokens ?? 256,
+            ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        });
+    }
+    /**
+     * The one-liner: hand it the running transcript, get back a silent directive
+     * (empty string when the agent is doing fine).
+     */
+    async whisper(transcript, opts = {}) {
+        const system = opts.guardrails ? `${COACH_SYSTEM}\n\nOperator rules:\n${opts.guardrails}` : COACH_SYSTEM;
+        const out = await this.oracle({
+            model: opts.model,
+            maxTokens: opts.maxTokens ?? 120,
+            ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
+            messages: [
+                { role: "system", content: system },
+                { role: "user", content: transcript },
+            ],
+        });
+        return out.text.trim();
+    }
+    /** Hosted TTS — returns raw audio bytes (WAV/PCM per voice). */
+    async tts(text, voice = "supafone-labs-calm-en") {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(this.baseUrl + "/v1/tts", {
+                method: "POST",
+                signal: ctrl.signal,
+                headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ voice, text }),
+            });
+            if (!res.ok)
+                throw new SupafoneLabsError(`tts: ${await res.text()}`, res.status);
+            return new Uint8Array(await res.arrayBuffer());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Hosted STT for a finished audio clip — returns transcript + language tags. */
+    async stt(audio, opts = {}) {
+        const bytes = audio instanceof ArrayBuffer ? new Uint8Array(audio) : audio;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(this.baseUrl + `/v1/stt?language=${encodeURIComponent(opts.language ?? "multi")}`, {
+                method: "POST",
+                signal: ctrl.signal,
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": opts.mimetype ?? "application/octet-stream",
+                },
+                body: bytes,
+            });
+            if (!res.ok)
+                throw new SupafoneLabsError(`stt: ${await res.text()}`, res.status);
+            const d = (await res.json());
+            // Flattened shape first; fall back to raw Deepgram nesting for older gateways.
+            const transcript = d.transcript ?? d.results?.channels?.[0]?.alternatives?.[0]?.transcript ?? "";
+            return { transcript, languages: d.languages ?? [], duration: d.duration ?? 0, raw: d };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Open a live multilingual transcription socket. Feed PCM frames with
+     * `feed()`; language-tagged results arrive via `onResult`. Uses the global
+     * WebSocket (browser, Node 22+); pass one in `opts.WebSocketImpl` on older Node.
+     */
+    liveTranscribe(opts = {}) {
+        return new LiveTranscription(this, opts);
+    }
+    /** Remaining prepaid balance. */
+    balance() {
+        return this.request("GET", "/v1/billing/balance");
+    }
+    /** Today's usage against your plan caps (oracle/tts/stt/…). */
+    usage() {
+        return this.request("GET", "/v1/usage");
+    }
+    /** The auditable whisper/billing log. */
+    logs(limit = 100) {
+        return this.request("GET", `/v1/logs?limit=${limit}`);
+    }
+    /** The structured whisper feed (what the console shows). */
+    nudges(limit = 50) {
+        return this.request("GET", `/v1/nudges?limit=${limit}`);
+    }
+    /** Aggregated metrics — injection rate, latency, by-dimension breakdowns. */
+    metrics(days = 7) {
+        return this.request("GET", `/v1/metrics?days=${days}`);
+    }
+    /** Log one whisper event (zero-billed) for the console feed + metrics. */
+    reportNudge(event) {
+        return this.request("POST", "/v1/events/nudge", event);
+    }
+    /** File a post-call report — the fuel optimizer.improve() learns from. */
+    reportCall(report) {
+        return this.request("POST", "/v1/events/call_report", report);
+    }
+    /** Available oracle model ids (live vendor catalog). */
+    async models() {
+        const d = await this.request("GET", "/v1/models");
+        return d.models.map((m) => (typeof m === "string" ? m : m.id));
+    }
+    /** Available TTS voice ids. */
+    async voices() {
+        const d = await this.request("GET", "/v1/voices");
+        return d.voices.map((v) => (typeof v === "string" ? v : (v.voice ?? v.id ?? ""))).filter(Boolean);
+    }
+}
+exports.SupafoneLabs = SupafoneLabs;
+exports.Supafone = SupafoneLabs;
+class LiveTranscription {
+    ws;
+    constructor(sm, opts) {
+        const WS = opts.WebSocketImpl ?? globalThis.WebSocket;
+        if (!WS)
+            throw new SupafoneLabsError("No WebSocket available — pass opts.WebSocketImpl (e.g. the `ws` package)");
+        const base = sm.baseUrl.replace(/^http/, "ws");
+        const q = new URLSearchParams({
+            // The key rides in the query string because browsers can't set WS headers.
+            api_key: sm.apiKey,
+            language: opts.language ?? "multi",
+            encoding: opts.encoding ?? "linear16",
+            sample_rate: String(opts.sampleRate ?? 16000),
+        });
+        this.ws = new WS(`${base}/v1/stt/live?${q}`);
+        this.ws.addEventListener?.("message", (ev) => {
+            const d = safeJson(typeof ev.data === "string" ? ev.data : String(ev.data));
+            const alt = d.channel?.alternatives?.[0];
+            if (alt?.transcript && opts.onResult) {
+                opts.onResult({ transcript: alt.transcript, languages: alt.languages ?? [], isFinal: !!d.is_final });
+            }
+        });
+        if (opts.onError)
+            this.ws.addEventListener?.("error", opts.onError);
+        if (opts.onClose)
+            this.ws.addEventListener?.("close", opts.onClose);
+    }
+    /** Send one PCM audio frame. */
+    feed(frame) {
+        this.ws.send(frame);
+    }
+    /** Signal end-of-stream and close. */
+    close() {
+        try {
+            this.ws.send(JSON.stringify({ type: "CloseStream" }));
+        }
+        catch {
+            /* already closing */
+        }
+        this.ws.close();
+    }
+    get socket() {
+        return this.ws;
+    }
+}
+/** Programmatic hosted Supafone agents, inside the Supafone API. */
+class LabsNamespace {
+    sm;
+    agents;
+    presets;
+    tools;
+    voices;
+    phoneNumbers;
+    telephony;
+    constructor(sm) {
+        this.sm = sm;
+        this.agents = new LabsAgentsNamespace(sm);
+        this.presets = new LabsPresetsNamespace(sm);
+        this.tools = new LabsToolsNamespace(sm);
+        this.voices = new LabsVoicesNamespace(sm);
+        this.phoneNumbers = new LabsPhoneNumbersNamespace(sm);
+        this.telephony = new LabsTelephonyNamespace(sm);
+    }
+    /** Discover the Supafone convenience layer over Ultravox. */
+    capabilities() {
+        return this.sm.requestSupafoneApi("GET", "/api/v1supafone-labs/capabilities");
+    }
+}
+class LabsAgentsNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Spawn a durable hosted Supafone agent backed by Ultravox and Supafone-managed providers. */
+    create(input) {
+        return this.sm.requestSupafoneApi("POST", "/api/v1supafone-labs/agents", labsAgentPayload(input));
+    }
+    /** Create an inbound receptionist/intake agent. No Twilio account is required. */
+    createInbound(input) {
+        return this.create({
+            ...input,
+            style: "inbound",
+            direction: "inbound",
+            agentType: input.agentType ?? input.agent_type ?? "phone",
+            presetKey: input.presetKey ?? input.preset_key ?? "general_intake_receptionist",
+            telephony: input.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        });
+    }
+    /** Create an outbound sales/speed-to-lead/campaign agent. No Twilio account is required. */
+    createOutbound(input) {
+        return this.create({
+            ...input,
+            style: "outbound",
+            direction: "outbound",
+            agentType: input.agentType ?? input.agent_type ?? "campaign",
+            presetKey: input.presetKey ?? input.preset_key ?? "speed_to_lead_caller",
+            telephony: input.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        });
+    }
+    /**
+     * Create an inbound agent, buy a Supafone-managed phone number, and assign it.
+     * This is the zero-Twilio-account happy path.
+     */
+    async createInboundWithNumber(input) {
+        const agent = await this.createInbound(input);
+        const agentKey = String(agent.agent?.agent_key ?? input.agentKey ?? input.agent_key ?? "");
+        const number = await new LabsPhoneNumbersNamespace(this.sm).buyAndAssign({
+            ...(input.number ?? {}),
+            agentKey,
+            agentName: input.assistantName ?? input.assistant_name ?? input.name,
+            friendlyName: input.number?.friendlyName ?? input.number?.friendly_name ?? input.name,
+            style: "inbound",
+            presetKey: input.presetKey ?? input.preset_key ?? "general_intake_receptionist",
+            telephony: input.number?.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        });
+        return { ...agent, number };
+    }
+    /**
+     * Create an outbound agent, buy a Supafone-managed caller ID, and assign it.
+     * For sales teams this is the easiest path: Supafone owns telephony setup.
+     */
+    async createOutboundWithNumber(input) {
+        const agent = await this.createOutbound(input);
+        const agentKey = String(agent.agent?.agent_key ?? input.agentKey ?? input.agent_key ?? "");
+        const number = await new LabsPhoneNumbersNamespace(this.sm).buyAndAssign({
+            ...(input.number ?? {}),
+            agentKey,
+            agentName: input.assistantName ?? input.assistant_name ?? input.name,
+            friendlyName: input.number?.friendlyName ?? input.number?.friendly_name ?? input.name,
+            style: "outbound",
+            presetKey: input.presetKey ?? input.preset_key ?? "speed_to_lead_caller",
+            telephony: input.number?.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        });
+        return { ...agent, number };
+    }
+    /** List durable agents created in the Supafone account tied to this API key. */
+    list(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.agencyId)
+            q.set("agency_id", opts.agencyId);
+        if (opts.agentType)
+            q.set("agent_type", opts.agentType);
+        if (opts.style)
+            q.set("style", opts.style);
+        const suffix = q.toString() ? `?${q}` : "";
+        return this.sm.requestSupafoneApi("GET", `/api/v1supafone-labs/agents${suffix}`);
+    }
+    /** Fetch one durable agent by key. */
+    get(agentKey, opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.agencyId)
+            q.set("agency_id", opts.agencyId);
+        if (opts.agentType)
+            q.set("agent_type", opts.agentType);
+        const suffix = q.toString() ? `?${q}` : "";
+        return this.sm.requestSupafoneApi("GET", `/api/v1supafone-labs/agents/${encodeURIComponent(agentKey)}${suffix}`);
+    }
+}
+class LabsPresetsNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Out-of-the-box multistage agent presets. */
+    list() {
+        return this.sm.requestSupafoneApi("GET", "/api/v1supafone-labs/presets");
+    }
+}
+class LabsToolsNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Built-in tools Supafone agents can use. */
+    list() {
+        return this.sm.requestSupafoneApi("GET", "/api/v1supafone-labs/tools");
+    }
+}
+class LabsVoicesNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Supafone-managed Ultravox, Cartesia, Inworld, and ElevenLabs-compatible voices. */
+    list(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.provider)
+            q.set("provider", opts.provider);
+        const suffix = q.toString() ? `?${q}` : "";
+        return this.sm.requestSupafoneApi("GET", `/api/v1supafone-labs/voices${suffix}`);
+    }
+}
+class LabsPhoneNumbersNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** List numbers already owned by this Supafone account. */
+    list(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.agencyId)
+            q.set("agency_id", opts.agencyId);
+        if (opts.activeOnly !== undefined)
+            q.set("active_only", String(opts.activeOnly));
+        const suffix = q.toString() ? `?${q}` : "";
+        return this.sm.requestSupafoneApi("GET", `/api/v1supafone-labs/phone-numbers${suffix}`);
+    }
+    /** Search Supafone-managed inventory. This uses Supafone's master telephony account. */
+    search(opts = {}) {
+        return this.sm.requestSupafoneApi("POST", "/api/v1supafone-labs/phone-numbers/search", phoneNumberSearchPayload(opts));
+    }
+    /** Buy a Supafone-managed number. Developers do not need a Twilio account. */
+    buy(input) {
+        return this.sm.requestSupafoneApi("POST", "/api/v1supafone-labs/phone-numbers", phoneNumberProvisionPayload({
+            ...input,
+            telephony: input.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        }));
+    }
+    /** Attach an existing Supafone number to an inbound or outbound agent. */
+    assign(numberId, input = {}) {
+        return this.sm.requestSupafoneApi("POST", `/api/v1supafone-labs/phone-numbers/${encodeURIComponent(numberId)}/assign`, phoneNumberAssignPayload(input));
+    }
+    /**
+     * Search if needed, buy the first matching Supafone-managed number, and assign
+     * it to the supplied agent. This is the zero-Twilio-account happy path.
+     */
+    async buyAndAssign(input) {
+        let phoneNumber = input.phoneNumber ?? input.phone_number ?? "";
+        if (!phoneNumber) {
+            const found = await this.search({
+                ...(input.search ?? {}),
+                agencyId: input.agencyId ?? input.agency_id ?? input.search?.agencyId,
+                limit: input.search?.limit ?? 1,
+            });
+            phoneNumber = found.numbers[0]?.phone_number ?? "";
+            if (!phoneNumber) {
+                throw new SupafoneLabsError("No Supafone-managed phone numbers matched the search");
+            }
+        }
+        return this.buy({
+            ...input,
+            phoneNumber,
+            telephony: input.telephony ?? { mode: "supafone_managed", provider: "supafone" },
+        });
+    }
+}
+class LabsTelephonyNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Read the account telephony contract. Defaults to Supafone-managed. */
+    get(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.agencyId)
+            q.set("agency_id", opts.agencyId);
+        const suffix = q.toString() ? `?${q}` : "";
+        return this.sm.requestSupafoneApi("GET", `/api/v1supafone-labs/telephony${suffix}`);
+    }
+    /** Configure advanced BYOK telephony, or reset back to Supafone-managed. */
+    configure(input) {
+        return this.sm.requestSupafoneApi("PUT", "/api/v1supafone-labs/telephony", telephonyPayload(input));
+    }
+    /** Reset to the seamless default where Supafone buys and routes numbers. */
+    useSupafoneManaged(agencyId) {
+        return this.configure({ agencyId, mode: "supafone_managed", provider: "supafone" });
+    }
+}
+/**
+ * The agent builder. These methods are account/session-scoped — call
+ * `login(email, password)` first, or the gateway returns 401 "Log in first".
+ */
+class BuilderNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** One supervised builder turn: whisper + guided agent reply. */
+    chat(sessionId, messages) {
+        return this.sm.request("POST", "/v1/builder/chat", { session_id: sessionId, messages }, true);
+    }
+    /** End a test call: grades it and files a report for the optimizer. */
+    finish(sessionId, messages) {
+        return this.sm.request("POST", "/v1/builder/finish", { session_id: sessionId, messages }, true);
+    }
+    config() {
+        return this.sm.request("GET", "/v1/builder/config", undefined, true);
+    }
+    saveConfig(config) {
+        return this.sm.request("POST", "/v1/builder/config", config, true);
+    }
+}
+class QANamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /**
+     * Run the adversarial QA suite, A/B (supervised vs unsupervised).
+     * Session-scoped — call login() first.
+     */
+    run(opts = {}) {
+        return this.sm.request("POST", "/v1/qa/run", { scenarios: opts.scenarios ?? [], turns: opts.turns ?? 2 }, true);
+    }
+    /** Past QA runs (works with the API key). */
+    history(agent = "builder", limit = 40) {
+        return this.sm.request("GET", `/v1/qa/runs?agent=${encodeURIComponent(agent)}&limit=${limit}`);
+    }
+}
+class OptimizerNamespace {
+    sm;
+    constructor(sm) {
+        this.sm = sm;
+    }
+    /** Improve the standing directive from accumulated call reports (OPRO-style). */
+    improve(agent = "builder") {
+        return this.sm.request("POST", "/v1/optimizer/improve", { agent });
+    }
+    /** Fetch the current standing directive. */
+    standing(agent = "builder") {
+        return this.sm.request("GET", `/v1/optimizer/standing?agent=${encodeURIComponent(agent)}`);
+    }
+    /** List the post-call reports behind the optimizer. */
+    reports(agent = "builder", limit = 40) {
+        return this.sm.request("GET", `/v1/optimizer/reports?agent=${encodeURIComponent(agent)}&limit=${limit}`);
+    }
+}
+function labsAgentPayload(input) {
+    return compact({
+        agency_id: input.agency_id ?? input.agencyId,
+        agent_key: input.agent_key ?? input.agentKey,
+        agent_type: input.agent_type ?? input.agentType,
+        style: input.agent_style ?? input.agentStyle ?? input.style,
+        name: input.name,
+        assistant_name: input.assistant_name ?? input.assistantName,
+        business_name: input.business_name ?? input.businessName,
+        industry: input.industry,
+        website_url: input.website_url ?? input.websiteUrl,
+        phone_number: input.phone_number ?? input.phoneNumber,
+        direction: input.direction,
+        preset_key: input.preset_key ?? input.presetKey,
+        runtime_mode: input.runtime_mode ?? input.runtimeMode,
+        goal: input.goal,
+        greeting: input.greeting,
+        system_prompt: input.system_prompt ?? input.systemPrompt,
+        language: input.language,
+        voice: input.voice ? voicePayload(input.voice) : undefined,
+        provider_keys: input.provider_keys ?? (input.providerKeys ? providerKeysPayload(input.providerKeys) : undefined),
+        byok: input.byok ? providerKeysPayload(input.byok) : undefined,
+        telephony: input.telephony ? telephonyPayload(input.telephony) : undefined,
+        tools: input.tools ? toolsPayload(input.tools) : undefined,
+        labs: input.labs ? labsPayload(input.labs) : undefined,
+        ultravox: input.ultravox ? ultravoxPayload(input.ultravox) : undefined,
+        voice_watcher: input.voice_watcher ?? input.voiceWatcher,
+        voice_watcher_model: input.voice_watcher_model ?? input.voiceWatcherModel,
+        metadata: input.metadata,
+    });
+}
+function telephonyPayload(input) {
+    return compact({
+        agency_id: input.agency_id ?? input.agencyId,
+        mode: input.mode,
+        provider: input.provider,
+        label: input.label,
+        credentials: input.credentials ? telephonyCredentialsPayload(input.credentials) : undefined,
+        metadata: input.metadata,
+    });
+}
+function telephonyCredentialsPayload(input) {
+    return compact({
+        account_sid: input.account_sid ?? input.accountSid,
+        auth_token: input.auth_token ?? input.authToken,
+        api_key: input.api_key ?? input.apiKey,
+        api_secret: input.api_secret ?? input.apiSecret,
+        auth_id: input.auth_id ?? input.authId,
+        connection_id: input.connection_id ?? input.connectionId,
+        from_number: input.from_number ?? input.fromNumber,
+        sip_trunk_uri: input.sip_trunk_uri ?? input.sipTrunkUri,
+        sip_host: input.sip_host ?? input.sipHost,
+        username: input.username,
+        password: input.password,
+        webhook_secret: input.webhook_secret ?? input.webhookSecret,
+    });
+}
+function phoneNumberSearchPayload(input) {
+    return compact({
+        agency_id: input.agency_id ?? input.agencyId,
+        country_code: input.country_code ?? input.countryCode,
+        area_code: input.area_code ?? input.areaCode,
+        postal_code: input.postal_code ?? input.postalCode,
+        zip_code: input.zip_code ?? input.zipCode,
+        contains: input.contains,
+        number_type: input.number_type ?? input.numberType,
+        limit: input.limit,
+        capabilities: input.capabilities,
+    });
+}
+function phoneNumberProvisionPayload(input) {
+    return compact({
+        agency_id: input.agency_id ?? input.agencyId,
+        phone_number: input.phone_number ?? input.phoneNumber,
+        friendly_name: input.friendly_name ?? input.friendlyName,
+        department_id: input.department_id ?? input.departmentId,
+        agent_key: input.agent_key ?? input.agentKey,
+        agent_id: input.agent_id ?? input.agentId,
+        agent_name: input.agent_name ?? input.agentName,
+        preset_key: input.preset_key ?? input.presetKey,
+        style: input.agent_style ?? input.agentStyle ?? input.style,
+        direction: input.direction,
+        telephony: input.telephony ? telephonyPayload(input.telephony) : undefined,
+        metadata: input.metadata,
+    });
+}
+function phoneNumberAssignPayload(input) {
+    return compact({
+        agency_id: input.agency_id ?? input.agencyId,
+        agent_key: input.agent_key ?? input.agentKey,
+        agent_id: input.agent_id ?? input.agentId,
+        agent_name: input.agent_name ?? input.agentName,
+        friendly_name: input.friendly_name ?? input.friendlyName,
+        preset_key: input.preset_key ?? input.presetKey,
+        style: input.agent_style ?? input.agentStyle ?? input.style,
+        direction: input.direction,
+        telephony: input.telephony ? telephonyPayload(input.telephony) : undefined,
+        metadata: input.metadata,
+    });
+}
+function voicePayload(input) {
+    return compact({
+        provider: input.provider,
+        voice_id: input.voice_id ?? input.voiceId,
+        model: input.model,
+    });
+}
+function providerKeysPayload(input) {
+    return compact({
+        ultravox: input.ultravox,
+        ultravox_api_key: input.ultravox_api_key ?? input.ultravoxApiKey,
+        elevenlabs: input.elevenlabs,
+        elevenlabs_api_key: input.elevenlabs_api_key ?? input.elevenlabsApiKey,
+        cartesia: input.cartesia,
+        cartesia_api_key: input.cartesia_api_key ?? input.cartesiaApiKey,
+        inworld: input.inworld,
+        inworld_api_key: input.inworld_api_key ?? input.inworldApiKey,
+        deepgram: input.deepgram,
+        deepgram_api_key: input.deepgram_api_key ?? input.deepgramApiKey,
+    });
+}
+function toolsPayload(input) {
+    return compact({
+        call_routing: input.call_routing ?? input.callRouting,
+        scheduling: input.scheduling,
+        sms: input.sms,
+        email: input.email,
+        intake_forms: input.intake_forms ?? input.intakeForms,
+        firm_knowledge: input.firm_knowledge ?? input.firmKnowledge,
+        existing_client_lookup: input.existing_client_lookup ?? input.existingClientLookup,
+        voicemail: input.voicemail,
+        emergency_escalation: input.emergency_escalation ?? input.emergencyEscalation,
+        custom_tools: input.custom_tools ?? input.customTools,
+    });
+}
+function labsPayload(input) {
+    return compact({
+        enabled: input.enabled,
+        voice_watcher: input.voice_watcher ?? input.voiceWatcher,
+        model: input.model,
+        label: input.label,
+    });
+}
+function ultravoxPayload(input) {
+    return compact({
+        model: input.model,
+        temperature: input.temperature,
+        medium: input.medium,
+        vadSettings: input.vadSettings ?? input.vad_settings,
+        speaker_first: input.speaker_first ?? input.speakerFirst,
+        firstSpeaker: input.firstSpeaker ?? input.first_speaker,
+        firstSpeakerSettings: input.firstSpeakerSettings ?? input.first_speaker_settings,
+        selectedTools: input.selectedTools ?? input.selected_tools,
+        initialMessages: input.initialMessages ?? input.initial_messages,
+        initialState: input.initialState ?? input.initial_state,
+        initialOutputMedium: input.initialOutputMedium ?? input.initial_output_medium,
+        joinTimeout: input.joinTimeout ?? input.join_timeout,
+        maxDuration: input.maxDuration ?? input.max_duration,
+        max_duration_seconds: input.max_duration_seconds ?? input.maxDurationSeconds,
+        timeExceededMessage: input.timeExceededMessage ?? input.time_exceeded_message,
+        inactivityMessages: input.inactivityMessages ?? input.inactivity_messages,
+        dataConnection: input.dataConnection ?? input.data_connection,
+        callbacks: input.callbacks,
+        metadata: input.metadata,
+        experimentalSettings: input.experimentalSettings ?? input.experimental_settings,
+        voiceOverrides: input.voiceOverrides ?? input.voice_overrides,
+        retentionPolicy: input.retentionPolicy ?? input.retention_policy,
+        callTemplate: input.callTemplate ?? input.call_template,
+    });
+}
+function compact(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { detail: text };
+    }
+}
+exports.default = SupafoneLabs;