supafone-labs 0.6.2 → 0.7.0

package/README.md

@@ -52,68 +52,100 @@ silent directive, and the exact primitive for each, is in
 
 ## Supported frameworks
 
-Silent injection feeds the live agent hidden guidance it acts on but never
-speaks. Two mechanisms cover every supported framework:
-
-- **Mode A — native silent event:** speech-to-speech models take a vendor event
-  that adds context without triggering speech.
-- **Mode B — own the LLM:** for STT→LLM→TTS pipelines, Supafone plugs in as the
-  LLM and splices a `system`/`developer` message into the prompt.
-
-**Possible — 10 frameworks**, each with a real injection door:
-
-| Framework | Mode | Exact primitive |
-| --- | :--: | --- |
-| Ultravox | A | `send_data_message` (`urgency:"later"`) — **live/proven today** |
-| OpenAI Realtime | A | `conversation.item.create` (role `system`, no `response.create`) |
-| Grok (xAI) | A | OpenAI-Realtime-compatible item inject |
-| Gemini Live | A | `clientContent` (`turnComplete:false`, role `user`) |
-| ElevenLabs | A | `contextual_update` |
-| Inworld | A | OpenAI-Realtime-compatible item inject |
-| Vapi | A+B | `add-message` (`triggerResponseEnabled:false`) or custom-LLM splice |
-| Retell | B | `system` message into the custom-LLM turn |
-| Deepgram | A+B | `UpdatePrompt`, or own the `think` LLM |
-| LiveKit | B | inject into `chat_ctx` in-process |
-
-**Impossible — Bland:** its live-call API is stop/listen/transfer only, with no
-mid-call inject channel and no custom-LLM. Observe and score it, but you cannot
-whisper to it live — a permanent vendor limitation, not a Supafone gap.
-**Cartesia** (a TTS voice) and **Pipecat** (a DIY framework you own end to end)
-are not conversational agents, so there is nothing to inject into.
-
-Injection is *possible* for all 10, but managed delivery is wired end-to-end
-**only for the legacy managed Supervisor delivery path**; the other nine are
-supported via their native primitive with managed delivery rolling out / BYO.
-Native realtime Agent Factory delivery is a separate first-class path. A live test against any vendor
-needs that vendor's key — free/trial tiers exist for all except OpenAI Realtime
-(paid, no free tier). Full matrix:
-[gitbook/framework-support.md](../gitbook/framework-support.md). *(The npm
-package-page copy updates on the next release.)*
-
-## Native realtime Agent Factory
-
-Version 0.6.1 can create direct speech-to-speech browser and phone agents with
-`realtime: { provider, model, voice }`. Supported entries are OpenAI GPT
-Realtime 2.1, GPT Live 1, Google Gemini Live 3.1, and xAI Grok Voice. Each
-entry keeps the same Supafone-managed, Twilio, Telnyx, Plivo, or SIP phone
-transport. Use `labs.agents.testCall(agentKey)` for an authenticated browser
-preview. Provider keys and carrier credentials are required for live calls; see
-the [full guide](../gitbook/realtime-agent-factory.md).
-
-| Provider | Model | Default voice |
+Supervisor delivers approved guidance through the control surface exposed by
+the selected adapter. The standalone SDK and hosted Agent Factory have separate
+capability contracts:
+
+- **Native control adapters:** Supafone/Ultravox, OpenAI Realtime, Grok,
+  Vapi, ElevenLabs Agents, Deepgram Voice Agent and Inworld Realtime.
+  For example, Ultravox uses a deferred data message; Grok uses
+  `response.create.instructions`, with `response.created` followed by
+  `response.done` as protocol acknowledgement.
+- **Developer-owned conversation context:** Retell custom LLM, LiveKit Agents
+  and Pipecat apply guidance inside the loop the integrator controls.
+- **Observation-only by default:** Gemini Developer Live and Bland emit no
+  hidden instruction through the default standalone adapter. Ordinary Gemini
+  `clientContent` is conversation history, not privileged system control.
+  Cartesia Line needs an explicit custom-event hook in the target agent.
+
+Hosted Agent Factory supports coaching across Ultravox, OpenAI, Gemini, Grok
+and Hydra through its managed call paths. Native calls use `check_guidance`
+tool results; Hydra's live observations are model-reported because it supplies
+no native transcript stream. This does not change the standalone adapter's
+capabilities or prove that a model followed the guidance.
+
+See the [framework matrix](../gitbook/framework-support.md) and
+[provider contracts](../docs/providers.md) for delivery and acceptance details.
+Live validation requires configured provider access; local contract tests do
+not certify a production call.
+
+## One S2S interface, five providers
+
+Since version 0.6.3, the SDK exports `SupafoneS2S`, the shared parent of `UltravoxS2S`,
+`OpenAIS2S`, `GeminiS2S`, `GrokS2S`, and `HydraS2S`. These classes use
+Supafone's hosted Agent Factory. Supafone handles the audio adapter, tools,
+stages, and supported phone transport behind one API.
+
+```ts
+import { Supafone, HydraS2S, OpenAIS2S, UltravoxS2S } from "supafone-labs";
+
+const client = new Supafone({ apiKey: process.env.SUPAFONE_API_KEY! });
+const hydra = new HydraS2S(client, { model: "hydra-v1.1", voice: "maya" });
+const created = await hydra.create({
+  name: "Intake", goal: "Collect the caller's details and book a consultation",
+  telephony: { mode: "supafone_managed", provider: "supafone" },
+});
+const agentKey = created.agent.agent_key!;
+await hydra.testCall(agentKey);
+
+// Switch the same agent for its next call, preserving its assigned number.
+await new OpenAIS2S(client, { model: "gpt-realtime-2.1", voice: "marin" }).apply(agentKey);
+// Return to the existing default Ultravox runtime.
+await new UltravoxS2S(client).apply(agentKey);
+```
+
+`apply` saves a selection for subsequent calls. `testCall` previews the saved
+agent and does not implicitly switch providers. The same constructors and
+`create`, `apply`, and `test_call` methods are available in Python.
+
+| Provider family | Selection | Default voice |
 | --- | --- | --- |
+| Ultravox | Default hosted runtime (`realtime: null` resets it) | Agent voice settings |
 | OpenAI | `gpt-realtime-2.1` | `marin` |
 | OpenAI | `gpt-live-1` | `marin` |
 | Google | `gemini-3.1-flash-live-preview` | `Puck` |
 | xAI | `grok-voice-latest` | `eve` |
-
-```ts
-const agent = await supafone.labs.agents.createInbound({
-  name: "Realtime intake",
-  realtime: { provider: "openai", model: "gpt-realtime-2.1", voice: "marin" },
-});
-const preview = await supafone.labs.agents.testCall(agent.agent.agent_key!);
-```
+| Smallest AI | `hydra-v1.1` | `maya` |
+| Smallest AI | `hydra-v1.0` | `sterling` |
+
+The existing `realtime: { provider, model, voice }` API remains supported.
+All five speaking families use the shared generated/custom stage plan, Manager
+and specialist consultations. The phone
+paths are Supafone-managed numbers, BYO Twilio, Telnyx, Plivo, and SIP through
+LiveKit. Carrier provisioning and credentials still determine call readiness.
+
+Supafone's configured server-side provider keys are used by default. An
+existing encrypted account key takes priority; customers do not need to add a
+provider key when Supafone has one configured. Missing keys produce an
+unavailable preview instead of a live provider call.
+
+Hydra supports English audio and tools, without transcript events or mutable
+mid-session persona/voice. Supafone supplies the frozen call plan at session start
+and advances the stage using tool results. Hydra 1.1 uses 16 kHz input / 24 kHz
+output; 1.0 uses 16 kHz / 48 kHz and a different voice roster. Native sessions
+support opt-in recording, public widgets, configured carrier controls and
+allowed-model handoff. A handoff opens a replacement session; a carrier transfer
+acknowledgement does not mean a human answered. Hydra has no live transcript
+stream; optional post-call transcription needs a recording and server Deepgram
+credentials. Ultravox retains compatible external TTS and its profile router.
+All five hosted speaking families support optional Supervisor coaching. Native
+models receive guidance through `check_guidance`; Hydra supplies explicitly
+labeled model-reported context rather than transcripts.
+See the [unified S2S guide](https://labs.supafone.ai/docs/unified-s2s/) and
+[capability matrix](https://labs.supafone.ai/docs/realtime-agent-factory/).
+See [Shared runtime, Manager and teams](https://labs.supafone.ai/docs/shared-agent-runtime/)
+for `manager`, `agentTeam`, structured stage requirements, `recording` and
+`runtimeRouting`. Both SDKs preserve explicit empty stage-tool and edge arrays.
 
 ## Spawn a hosted Supafone agent
 
@@ -198,7 +230,7 @@ import { Supafone } from "supafone-labs";
 const supafone = new Supafone({
   apiKey: process.env.SUPAFONE_LABS_API_KEY || process.env.SUPAFONE_API_KEY!,
   supafoneApiKey: process.env.SUPAFONE_API_KEY!,
-  // Supafone Supervisor is on by default for live guidance, QA, and scoring.
+  // Requests Supervisor by default; its model credentials must also be configured.
   // Set false only when you intentionally need an unsupervised agent.
   supervisor: true,
   // Defaults to https://api.supafone.ai. Override for staging/local tests.
@@ -226,11 +258,7 @@ const inbound = await supafone.labs.agents.createInboundWithNumber({
   },
   recording: {
     enabled: true,
-    recordAudio: true,
-    consentRequired: true,
-    announcement: "This call may be recorded for quality and training.",
-    retentionDays: 30,
-    redactPii: true,
+    transcribe: true,
   },
   transcription: {
     enabled: true,
@@ -353,37 +381,40 @@ agent; fetches it back; verifies `runtime.telephony.mode` is `supafone_managed`
 and the runtime is managed (`runtime.managed === true`, no developer Ultravox key
 required); and prints the returned widget snippet.
 
-## Hosted voices
+## Hosted voices: Ultravox + custom TTS
 
-Select a current provider voice from plain-language intent:
+The managed Ultravox option remains part of the shared S2S offering. Its
+conversation runtime and compatible TTS voice are separate choices:
 
 ```ts
-const matches = await supafone.labs.voices.recommend({
-  description: "calm Spanish customer-support voice",
-  language: "es-MX",
-  configuredOnly: true,
-});
+import { UltravoxS2S } from "supafone-labs";
+
+const catalog = await supafone.labs.voices.list({ provider: "cartesia" });
+console.log(catalog.voices);
 
-const voice = matches.matches[0].voice;
-await supafone.labs.agents.createInbound({
+await new UltravoxS2S(supafone).create({
   name: "Spanish support",
-  voice: supafone.labs.voices.selection(voice),
+  voice: { provider: "cartesia", voiceId: process.env.CARTESIA_VOICE_ID! },
 });
 ```
 
-The hosted catalog refreshes Ultravox, Cartesia, ElevenLabs, and Inworld and
-normalizes names, languages, gender, accent, voice type, model limits, and the
-Ultravox-compatible language intersection. Full reference:
-[Dynamic Voice Catalog and Selection](../gitbook/voice-catalog-and-selection.md).
-
-Labs Cloud also exposes direct hosted TTS and STT:
-
-```ts
-const wav = await supafone.tts("You're all set — talk soon!", "supafone-labs-calm-en");
-// wav: Uint8Array
-
-const text = await supafone.stt(audioBytes, { language: "en" });
-```
+Use a real, configured catalog voice. Compatible Ultravox, Cartesia, ElevenLabs,
+and Inworld voices can supply the managed agent's speech. Native OpenAI,
+Gemini, Grok, and Hydra use their own model voices; external TTS is not a
+universal override. Deepgram is preview-only in the current hosted Ultravox
+integration. Custom TTS backends are for developer-owned synthesis unless a
+hosted runtime bridge explicitly supports them.
+
+The published SDK 0.7.0 exposes `labs.voices.list`, `listAll`, `capabilities`,
+`recommend`, `preview`, and `selection`. Use `listAll` for automatic catalog
+pagination, then pass `selection(voice)` into managed agent creation. These
+helpers query the hosted voice catalog; they do not enable external TTS on
+native OpenAI, Gemini, Grok, or Hydra sessions.
+See [voice-output choices](https://labs.supafone.ai/docs/voice-output-modes/) and
+[the voice catalog](https://labs.supafone.ai/docs/voice-catalog-and-selection/).
+
+Labs Cloud's standalone `tts` and `stt` methods remain separate synthesis and
+transcription tools; using them does not change a saved agent's speaking model.
 
 ## Live multilingual transcription
 

package/dist/cjs/index.d.ts

@@ -1,3 +1,5 @@
+export { SupafoneS2S, UltravoxS2S, OpenAIS2S, GeminiS2S, GrokS2S, HydraS2S } from "./s2s.js";
+export type { S2SProviderName, S2SModelOptions, S2SOptions } from "./s2s.js";
 /**
  * Supafone Labs — the agent framework behind Supafone.
  *
@@ -197,8 +199,74 @@ export interface LabsCallStage {
     temperature?: number;
     nextStages?: string[];
     next_stages?: string[];
+    /** Server-enforced exit gates, independent of conversational exit criteria. */
+    requirements?: LabsStageRequirements;
+    role?: string;
+    specialistId?: string;
+    specialist_id?: string;
     metadata?: Record<string, unknown>;
 }
+export interface LabsStageRequirements {
+    requiredFields?: string[];
+    required_fields?: string[];
+    successfulTools?: string[];
+    successful_tools?: string[];
+}
+export interface LabsManagerConfig {
+    enabled?: boolean;
+    /** Reuse the existing encrypted Supervisor profile, or use managed reasoning. */
+    reasoning?: "managed" | "supervisor";
+    model?: "supafone-manager" | "supafone-manager-pro";
+    maxTasks?: number;
+    max_tasks?: number;
+    maxParallel?: number;
+    max_parallel?: number;
+    timeoutSeconds?: number;
+    timeout_seconds?: number;
+}
+export interface LabsSpecialist {
+    id: string;
+    role?: string;
+    label?: string;
+    description?: string;
+    instructions?: string;
+    enabled?: boolean;
+    stageKeys?: string[];
+    stage_keys?: string[];
+    tools?: string[];
+}
+export interface LabsAgentTeam {
+    enabled?: boolean;
+    routingMode?: "auto" | "sequential";
+    routing_mode?: "auto" | "sequential";
+    fallbackMemberId?: string;
+    fallback_member_id?: string;
+    members?: LabsSpecialist[];
+    routingRules?: Array<{
+        intent: string;
+        member_id: string;
+        priority?: string;
+        action?: string;
+    }>;
+    routing_rules?: Array<{
+        intent: string;
+        member_id: string;
+        priority?: string;
+        action?: string;
+    }>;
+}
+export interface LabsRuntimeRoutingConfig {
+    enabled?: boolean;
+    allowedModels?: LabsRealtimeSelection[];
+    allowed_models?: LabsRealtimeSelection[];
+    /** Server-supported range is 1–3 handoffs per call. */
+    maxHandoffs?: number;
+    max_handoffs?: number;
+    recoverOnDisconnect?: boolean;
+    recover_on_disconnect?: boolean;
+    allowedLanguages?: string[];
+    allowed_languages?: string[];
+}
 export type LabsStageGeneration = "managed" | "template" | "off" | "oracle";
 export interface LabsCallPlan {
     version: "supafone_call_plan_v1" | string;
@@ -353,7 +421,7 @@ export interface LabsVoicePreference {
 }
 /** Direct speech-to-speech configuration for browser previews and carrier phone calls. */
 export interface LabsRealtimeSelection {
-    provider: "openai" | "google" | "xai";
+    provider: "openai" | "google" | "xai" | "smallest";
     model?: string;
     voice?: string;
 }
@@ -373,6 +441,17 @@ export interface LabsBrowserTestSession {
         token?: string | null;
         input_sample_rate?: number;
         output_sample_rate?: number;
+        capabilities?: {
+            stages?: boolean;
+            tools?: boolean;
+            transcripts?: boolean;
+            recording?: boolean;
+            supervisor?: boolean;
+            transfer?: boolean;
+            mutable_instructions?: boolean;
+            stage_update_mode?: string;
+            languages?: string[];
+        };
     };
 }
 export interface LabsProviderKeys {
@@ -449,6 +528,9 @@ export interface LabsProviderKeys {
     xai?: string;
     xaiApiKey?: string;
     xai_api_key?: string;
+    smallest?: string;
+    smallestApiKey?: string;
+    smallest_api_key?: string;
     [extra: string]: unknown;
 }
 export interface LabsCustomSipConfig {
@@ -630,6 +712,8 @@ export interface LabsEmailConfig {
 }
 export interface LabsRecordingConfig {
     enabled?: boolean;
+    /** Request post-call transcription of the recording where configured. */
+    transcribe?: boolean;
     recordAudio?: boolean;
     record_audio?: boolean;
     consentRequired?: boolean;
@@ -869,6 +953,17 @@ export interface CreateLabsAgentRequest {
     presetKey?: string;
     preset_key?: string;
     realtime?: LabsRealtimeSelection;
+    manager?: boolean | LabsManagerConfig;
+    agentTeam?: LabsAgentTeam;
+    agent_team?: LabsAgentTeam;
+    runtimeRouting?: LabsRuntimeRoutingConfig;
+    runtime_routing?: LabsRuntimeRoutingConfig;
+    captureFields?: string[];
+    capture_fields?: string[];
+    timezone?: string;
+    businessTimezone?: string;
+    timeAwareness?: boolean;
+    time_awareness?: boolean;
     runtimeMode?: LabsRuntimeMode;
     runtime_mode?: LabsRuntimeMode;
     /** Defaults to Supafone's hosted planner; model credentials remain server-side. */
@@ -911,7 +1006,7 @@ export interface CreateLabsAgentRequest {
     customSip?: LabsCustomSipConfig;
     custom_sip?: LabsCustomSipConfig;
     sip?: LabsCustomSipConfig;
-    recording?: LabsRecordingConfig;
+    recording?: boolean | LabsRecordingConfig;
     transcription?: LabsTranscriptionConfig;
     artifacts?: LabsArtifactsConfig;
     compliance?: Record<string, unknown>;
@@ -2217,7 +2312,7 @@ declare class LabsBillingNamespace {
 declare class LabsAgentsNamespace {
     private sm;
     constructor(sm: SupafoneLabs);
-    /** Spawn a durable hosted Supafone agent backed by Ultravox and Supafone-managed providers. */
+    /** Create a hosted Supafone agent with the default Ultravox runtime or a selected native S2S model. */
     create(input: CreateLabsAgentRequest): Promise<CreateLabsAgentResponse>;
     /** Preview the exact validated call-plan contract the Supafone runtime executes. */
     plan(input: CreateLabsAgentRequest & {

package/dist/cjs/index.js

@@ -1,30 +1,16 @@
 "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 Supervisor. It also
- * includes Supafone Supervisor, 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 supafone-labs
- *
- *   import { Supafone } from "supafone-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 = exports.OUTBOUND_CALL_MODE_PROVIDER_MATRIX = exports.OUTBOUND_CALL_MODE_DEFAULTS = exports.OUTBOUND_CALL_MODE_BOUNDS = void 0;
+exports.Supafone = exports.SupafoneLabs = exports.SupafoneLabsError = exports.OUTBOUND_CALL_MODE_PROVIDER_MATRIX = exports.OUTBOUND_CALL_MODE_DEFAULTS = exports.OUTBOUND_CALL_MODE_BOUNDS = exports.HydraS2S = exports.GrokS2S = exports.GeminiS2S = exports.OpenAIS2S = exports.UltravoxS2S = exports.SupafoneS2S = void 0;
 exports.outboundCallModeProviderProfile = outboundCallModeProviderProfile;
 exports.outboundCallModeReadiness = outboundCallModeReadiness;
 exports.generateCallStages = generateCallStages;
+var s2s_js_1 = require("./s2s.js");
+Object.defineProperty(exports, "SupafoneS2S", { enumerable: true, get: function () { return s2s_js_1.SupafoneS2S; } });
+Object.defineProperty(exports, "UltravoxS2S", { enumerable: true, get: function () { return s2s_js_1.UltravoxS2S; } });
+Object.defineProperty(exports, "OpenAIS2S", { enumerable: true, get: function () { return s2s_js_1.OpenAIS2S; } });
+Object.defineProperty(exports, "GeminiS2S", { enumerable: true, get: function () { return s2s_js_1.GeminiS2S; } });
+Object.defineProperty(exports, "GrokS2S", { enumerable: true, get: function () { return s2s_js_1.GrokS2S; } });
+Object.defineProperty(exports, "HydraS2S", { enumerable: true, get: function () { return s2s_js_1.HydraS2S; } });
 exports.OUTBOUND_CALL_MODE_BOUNDS = {
     maxDurationSeconds: { default: 180, min: 30, max: 900 },
     maxKeypresses: { default: 12, min: 1, max: 64 },
@@ -1202,7 +1188,7 @@ class LabsAgentsNamespace {
     constructor(sm) {
         this.sm = sm;
     }
-    /** Spawn a durable hosted Supafone agent backed by Ultravox and Supafone-managed providers. */
+    /** Create a hosted Supafone agent with the default Ultravox runtime or a selected native S2S model. */
     create(input) {
         return this.sm.requestSupafoneApi("POST", "/api/v1/labs/agents", labsAgentPayload(this.withSupervisor(input)));
     }
@@ -2029,6 +2015,40 @@ function outboundCallModeRequiredCapabilities(payload) {
         required.push("observability");
     return required;
 }
+function managerPayload(input) {
+    if (typeof input !== "object" || input === null)
+        return input;
+    return compact({
+        enabled: input.enabled, reasoning: input.reasoning, model: input.model,
+        max_tasks: input.max_tasks ?? input.maxTasks,
+        max_parallel: input.max_parallel ?? input.maxParallel,
+        timeout_seconds: input.timeout_seconds ?? input.timeoutSeconds,
+    });
+}
+function agentTeamPayload(input) {
+    if (!input)
+        return undefined;
+    return compact({
+        enabled: input.enabled, routing_mode: input.routing_mode ?? input.routingMode,
+        fallback_member_id: input.fallback_member_id ?? input.fallbackMemberId,
+        routing_rules: input.routing_rules ?? input.routingRules,
+        members: input.members?.map((member) => compact({
+            id: member.id, role: member.role, label: member.label, description: member.description,
+            instructions: member.instructions, enabled: member.enabled, tools: member.tools,
+            stage_keys: member.stage_keys ?? member.stageKeys,
+        })),
+    });
+}
+function runtimeRoutingPayload(input) {
+    if (!input)
+        return undefined;
+    return compact({
+        enabled: input.enabled, allowed_models: input.allowed_models ?? input.allowedModels,
+        max_handoffs: input.max_handoffs ?? input.maxHandoffs,
+        recover_on_disconnect: input.recover_on_disconnect ?? input.recoverOnDisconnect,
+        allowed_languages: input.allowed_languages ?? input.allowedLanguages,
+    });
+}
 function labsAgentMetadataPayload(input) {
     const metadata = { ...(input.metadata ?? {}) };
     const mode = input.outboundCallMode ?? input.outbound_call_mode;
@@ -2070,6 +2090,12 @@ function labsAgentPayload(input) {
         preset_key: input.preset_key ?? input.presetKey,
         runtime_mode: input.runtime_mode ?? input.runtimeMode,
         realtime: input.realtime,
+        manager: managerPayload(input.manager),
+        agent_team: agentTeamPayload(input.agent_team ?? input.agentTeam),
+        runtime_routing: runtimeRoutingPayload(input.runtime_routing ?? input.runtimeRouting),
+        capture_fields: input.capture_fields ?? input.captureFields,
+        timezone: input.timezone ?? input.businessTimezone,
+        time_awareness: input.time_awareness ?? input.timeAwareness,
         call_stages: callStagesPayload(input),
         stage_generation: input.stage_generation ?? input.stageGeneration,
         stage_count: input.stage_count ?? input.stageCount,
@@ -2087,7 +2113,7 @@ function labsAgentPayload(input) {
         byok: input.byok ? byokPayload(input.byok) : undefined,
         telephony: input.telephony ? telephonyPayload(input.telephony) : undefined,
         custom_sip: customSipPayload(input.custom_sip ?? input.customSip ?? input.sip),
-        recording: input.recording ? recordingPayload(input.recording) : undefined,
+        recording: input.recording !== undefined ? recordingPayload(input.recording) : undefined,
         transcription: input.transcription ? transcriptionPayload(input.transcription) : undefined,
         artifacts: input.artifacts ? artifactsPayload(input.artifacts) : undefined,
         compliance: input.compliance,
@@ -2231,9 +2257,6 @@ function callStagesPayload(input) {
         return explicit;
     if (explicit === "oracle")
         return "managed";
-    // The S2S backend owns its validated intake → booking → confirmation flow.
-    if (input.realtime)
-        return undefined;
     // Omitted means the private Supafone API generates and compiles the plan.
     return undefined;
 }
@@ -2250,8 +2273,7 @@ function stagePlanPayload(input) {
         system_prompt: input.system_prompt ?? input.systemPrompt,
         tools: input.tools ? toolsPayload(input.tools) : undefined,
         call_stages: Array.isArray(input.call_stages ?? input.callStages ?? input.stages)
-            ? (input.call_stages ?? input.callStages ?? input.stages)
-            : undefined,
+            ? callStagesPayload(input) : undefined,
         stage_generation: input.stage_generation ?? input.stageGeneration,
         stage_count: input.stage_count ?? input.stageCount,
         stage_detail: input.stage_detail ?? input.stageDetail,
@@ -2267,6 +2289,12 @@ function callStagePayload(input) {
         tools: input.tools,
         temperature: input.temperature,
         next_stages: input.next_stages ?? input.nextStages,
+        requirements: input.requirements ? compact({
+            required_fields: input.requirements.required_fields ?? input.requirements.requiredFields,
+            successful_tools: input.requirements.successful_tools ?? input.requirements.successfulTools,
+        }) : undefined,
+        role: input.role,
+        specialist_id: input.specialist_id ?? input.specialistId,
         metadata: input.metadata,
     });
 }
@@ -2408,6 +2436,8 @@ function providerKeysPayload(input) {
         openai_api_key: input.openai_api_key ?? input.openaiApiKey,
         xai: input.xai,
         xai_api_key: input.xai_api_key ?? input.xaiApiKey,
+        smallest: input.smallest,
+        smallest_api_key: input.smallest_api_key ?? input.smallestApiKey,
     });
 }
 function byokPayload(input) {
@@ -2483,8 +2513,11 @@ function emailPayload(input) {
     });
 }
 function recordingPayload(input) {
+    if (typeof input === "boolean")
+        return input;
     return compact({
         enabled: input.enabled,
+        transcribe: input.transcribe,
         record_audio: input.record_audio ?? input.recordAudio,
         consent_required: input.consent_required ?? input.consentRequired,
         announcement: input.announcement,

package/dist/cjs/s2s.d.ts

@@ -0,0 +1,41 @@
+import type { CreateLabsAgentRequest, GetLabsAgentOptions, LabsRealtimeSelection, SupafoneLabs } from "./index.js";
+export type S2SProviderName = "ultravox" | "openai" | "google" | "xai" | "smallest";
+export interface S2SModelOptions {
+    model?: string;
+    voice?: string;
+}
+export interface S2SOptions extends S2SModelOptions {
+    provider?: S2SProviderName;
+}
+/** Shared parent for Supafone-hosted S2S agents. Vendor keys stay on the server. */
+export declare class SupafoneS2S {
+    protected readonly client: SupafoneLabs;
+    readonly provider: S2SProviderName;
+    private readonly selection;
+    constructor(client: SupafoneLabs, options?: S2SOptions);
+    /** A fresh wire selection; null explicitly restores the default Ultravox runtime. */
+    get realtime(): LabsRealtimeSelection | null;
+    /** Create through the normal hosted agent factory with this provider. */
+    create(input: Omit<CreateLabsAgentRequest, "realtime">): Promise<import("./index.js").CreateLabsAgentResponse>;
+    /** Change the saved selection for subsequent calls, preserving the agent and number. */
+    apply(agentKey: string, options?: GetLabsAgentOptions): Promise<import("./index.js").LabsAgentLifecycleResponse>;
+    /** Preview the saved agent. Call apply first when switching providers. */
+    testCall(agentKey: string, options?: GetLabsAgentOptions): Promise<import("./index.js").LabsBrowserTestSession>;
+    private checkAgentKey;
+}
+export declare class UltravoxS2S extends SupafoneS2S {
+    constructor(client: SupafoneLabs);
+}
+export declare class OpenAIS2S extends SupafoneS2S {
+    constructor(client: SupafoneLabs, options?: S2SModelOptions);
+}
+export declare class GeminiS2S extends SupafoneS2S {
+    constructor(client: SupafoneLabs, options?: S2SModelOptions);
+}
+export declare class GrokS2S extends SupafoneS2S {
+    constructor(client: SupafoneLabs, options?: S2SModelOptions);
+}
+/** Smallest AI Hydra: full-duplex audio, without transcript events. */
+export declare class HydraS2S extends SupafoneS2S {
+    constructor(client: SupafoneLabs, options?: S2SModelOptions);
+}