@specific.dev/spectest 0.111.0 → 0.113.0

package/dist/harness/phone.py

@@ -0,0 +1,427 @@
+"""SDK-owned JSON-lines adapter for the golden's PJSUA2 and Supertonic runtime.
+
+SIP runs exclusively on this thread; synthesis runs in a background thread so
+INVITE/BYE/retransmissions continue to be serviced while ONNX is busy.
+"""
+import concurrent.futures
+import json
+import os
+import queue
+import sys
+import tempfile
+import threading
+import time
+import wave
+import math
+from array import array
+from phone_recording import StreamingRecording, MEDIA_RATE, PEAK_SAMPLES
+
+# PJSIP writes directly to fd 1. Keep the protocol on a private duplicate.
+protocol = os.fdopen(os.dup(1), "w", buffering=1)
+os.dup2(2, 1)
+import pjsua2 as pj
+
+
+
+def configure_codecs(endpoint):
+    """Offer every installed codec, preferring Opus then higher sample rates."""
+    def preference(codec):
+        name, rate, channels = codec.codecId.lower().split("/")
+        return (name == "opus", int(rate), channels == "1",
+                name in ("g722", "pcma", "pcmu"), codec.priority)
+
+    for index, codec in enumerate(sorted(endpoint.codecEnum2(), key=preference, reverse=True)):
+        endpoint.codecSetPriority(codec.codecId, max(1, 240 - index))
+
+
+class IncomingAudio(pj.AudioMediaPort):
+    """Observe only received PCM; outgoing speech never resets this timer."""
+    def __init__(self):
+        super().__init__()
+        self.last_voice = time.monotonic()
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = 16000
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort("incoming-silence", fmt)
+
+    def onFrameReceived(self, frame):
+        samples = array("h", bytes(frame.buf))
+        if samples and sum(sample * sample for sample in samples) / len(samples) > 250 ** 2:
+            self.last_voice = time.monotonic()
+
+
+class Recording(pj.AudioMediaPort):
+    """The recording and every clip boundary share the same PCM sample clock.
+
+    The media clock can fall behind monotonic time under load (notably while
+    Python imports the TTS runtime). Wall time is not a position in the recording.
+    """
+    def __init__(self, path):
+        super().__init__()
+        self.frames = 0
+        self.lock = threading.Lock()
+        self.tracks = {"callerPeaks": [], "recipientPeaks": []}
+        self.audio = StreamingRecording(path)
+        self.closed = False
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = MEDIA_RATE
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort("call-recording", fmt)
+
+    def onFrameReceived(self, frame):
+        pcm = bytes(frame.buf)
+        with self.lock:
+            if not self.closed:
+                self.audio.write(pcm)
+                self.frames += len(pcm) // 2
+
+    @property
+    def offset(self):
+        with self.lock:
+            return self.frames / MEDIA_RATE
+
+    def observe(self, side, pcm):
+        samples = array("h", pcm)
+        if not samples:
+            return
+        peak = max(abs(min(samples)), abs(max(samples))) / 32768
+        with self.lock:
+            if self.closed:
+                return
+            # Meter ports follow the mixed sink in the conference bridge.
+            # Locate this 20ms frame using the recording's PCM clock, never wall time.
+            first = max(0, self.frames - len(samples)) // PEAK_SAMPLES
+            last = max(0, self.frames - 1) // PEAK_SAMPLES
+            peaks = self.tracks[side]
+            peaks.extend([0.0] * max(0, last + 1 - len(peaks)))
+            for index in range(first, last + 1):
+                peaks[index] = max(peaks[index], round(peak, 4))
+
+    def finish(self):
+        with self.lock:
+            self.closed = True
+        return self.audio.finish()
+
+
+class WaveformMeter(pj.AudioMediaPort):
+    """Observe a single direction without creating another audio recording."""
+    def __init__(self, recorder, side):
+        super().__init__()
+        self.recorder, self.side = recorder, side
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = MEDIA_RATE
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort(side, fmt)
+
+    def onFrameReceived(self, frame):
+        self.recorder.observe(self.side, bytes(frame.buf))
+
+
+class Call(pj.Call):
+    def __init__(self, account, endpoint, directory, session_id):
+        super().__init__(account)
+        self.endpoint = endpoint
+        self.session_id = session_id
+        self.path = os.path.join(directory, session_id + ".webm")
+        self.sealed = False
+        self.capture_error = None
+        self.recorder = Recording(self.path)
+        self.caller_meter = WaveformMeter(self.recorder, "callerPeaks")
+        self.recipient_meter = WaveformMeter(self.recorder, "recipientPeaks")
+        # Keep the sink clocked even during silence, synthesis, and app waits.
+        self.clock = endpoint.audDevManager().getCaptureDevMedia()
+        self.clock.startTransmit(self.recorder)
+        self.started_at_ms = time.time() * 1000
+        self.started = time.monotonic()
+        self.connected = False
+        self.disconnected = False
+        self.status = 0
+        self.media = None
+        self.incoming = IncomingAudio()
+
+    def onCallState(self, _):
+        info = self.getInfo()
+        self.connected = info.state == pj.PJSIP_INV_STATE_CONFIRMED
+        self.disconnected = info.state == pj.PJSIP_INV_STATE_DISCONNECTED
+        self.status = info.lastStatusCode
+
+    def onCallMediaState(self, _):
+        self.media = None
+        info = self.getInfo()
+        for item in info.media:
+            if item.type == pj.PJMEDIA_TYPE_AUDIO and item.status == pj.PJSUA_CALL_MEDIA_ACTIVE:
+                self.media = self.getAudioMedia(item.index)
+                try:
+                    self.media.startTransmit(self.recorder)
+                    self.media.startTransmit(self.recipient_meter)
+                    self.media.startTransmit(self.incoming)
+                except Exception:
+                    self.capture_error = "Could not connect incoming call audio to the recorder"
+                break
+
+
+    def finish_recording(self):
+        if self.sealed:
+            return
+        self.sealed = True
+        result = {"event": "recording", "sessionId": self.session_id,
+                  "startedAtMs": self.started_at_ms, "duration": 0, "bytes": 0,
+                  "contentType": "audio/webm", "peaks": []}
+        try:
+            self.clock.stopTransmit(self.recorder)
+            if self.media is not None:
+                try:
+                    self.media.stopTransmit(self.recorder)
+                    self.media.stopTransmit(self.recipient_meter)
+                except Exception:
+                    pass  # The remote peer may already have removed its port.
+            result.update(self.recorder.finish())
+            peaks = result["peaks"]
+            for side, track in self.recorder.tracks.items():
+                result[side] = (track + [0.0] * max(0, len(peaks) - len(track)))[:len(peaks)]
+            if self.capture_error:
+                result["error"] = self.capture_error
+        except Exception:
+            result["error"] = "Call recording could not be finalized"
+        protocol.write(json.dumps(result) + "\n")
+
+
+class Player(pj.AudioMediaPlayer):
+    def __init__(self):
+        super().__init__()
+        self.done = False
+
+    def onEof2(self):
+        self.done = True
+
+
+def synthesize(data, options, path):
+    import numpy as np
+    from supertonic import TTS
+    # Retain the loaded model for subsequent say calls on this phone.
+    if not hasattr(synthesize, "tts"):
+        synthesize.tts = TTS(model="supertonic-3", model_dir="/opt/spectest/phone/models",
+                             auto_download=False, intra_op_num_threads=2, inter_op_num_threads=1)
+    tts = synthesize.tts
+    np.random.seed(0)
+    style = tts.get_voice_style(data.get("voice", options.get("voice", "F1")))
+    # The high-level synthesize() API splits paragraphs/sentences. Send the
+    # complete utterance to the model in one invocation instead.
+    from supertonic.config import AVAILABLE_LANGUAGES
+    language = data.get("language", "en")
+    if language not in AVAILABLE_LANGUAGES:
+        raise ValueError(f"Unsupported speech language: {language}")
+    text = data["text"]
+    valid, unsupported = tts.model.text_processor.validate_text(text)
+    if not valid:
+        raise ValueError(f"Speech contains {len(unsupported)} unsupported characters")
+    audio, duration = tts.model([text], style, total_step=5,
+                                speed=data.get("speed", 1.05), lang=language)
+    audio = audio.reshape(-1)[:int(float(duration[0]) * tts.sample_rate)]
+    if len(audio) > tts.sample_rate * 60:
+        raise ValueError("Speech exceeds the 60 second limit; use a shorter utterance")
+    # PJSIP's WAV player accepts mono 16-bit PCM and resamples to the SIP codec.
+    pcm = (np.clip(audio, -1, 1) * 32767).astype("<i2")
+    with wave.open(path, "wb") as out:
+        out.setnchannels(1)
+        out.setsampwidth(2)
+        out.setframerate(tts.sample_rate)
+        out.writeframes(pcm.tobytes())
+    return {"duration": len(audio) / tts.sample_rate}
+
+
+
+def main():
+    inbox = queue.Queue()
+    ended = threading.Event()
+
+    def read():
+        try:
+            for line in sys.stdin:
+                inbox.put(json.loads(line))
+        finally:
+            ended.set()
+    threading.Thread(target=read, daemon=True).start()
+    endpoint, account, call = None, None, None
+    options = {}
+    executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+
+    def pump():
+        if ended.is_set():
+            raise EOFError()
+        if endpoint:
+            endpoint.libHandleEvents(10)
+            if call and call.disconnected:
+                call.finish_recording()
+            elif call and time.monotonic() - call.started > 900:
+                call.capture_error = "Call exceeded the 15 minute recording limit"
+                call.hangup(pj.CallOpParam())
+        else:
+            time.sleep(0.01)
+
+    def wait(predicate, timeout, live=False):
+        deadline = time.monotonic() + timeout
+        while not predicate():
+            if live and call.disconnected:
+                raise ValueError(f"SIP call ended ({call.status})")
+            if time.monotonic() >= deadline:
+                raise ValueError("SIP operation timed out")
+            pump()
+
+    def hangup():
+        if call and not call.disconnected:
+            call.hangup(pj.CallOpParam())
+            wait(lambda: call.disconnected, 5)
+
+    try:
+        while not ended.is_set():
+            try:
+                data = inbox.get_nowait()
+            except queue.Empty:
+                pump()
+                continue
+            result = {}
+            try:
+                action = data["action"]
+                if call and action != "call":
+                    protocol.write(json.dumps({"event": "operation_started", "id": data["id"],
+                                               "offset": call.recorder.offset}) + "\n")
+                if action == "open":
+                    options = data
+                    endpoint = pj.Endpoint()
+                    endpoint.libCreate()
+                    cfg = pj.EpConfig()
+                    cfg.uaConfig.threadCnt = 0
+                    cfg.uaConfig.mainThreadOnly = True
+                    cfg.logConfig.level = 0
+                    cfg.logConfig.consoleLevel = 0
+                    cfg.medConfig.clockRate = MEDIA_RATE
+                    endpoint.libInit(cfg)
+                    transport = pj.TransportConfig()
+                    transport.port = 0
+                    kind = pj.PJSIP_TRANSPORT_TCP if data.get("transport") == "tcp" else pj.PJSIP_TRANSPORT_UDP
+                    endpoint.transportCreate(kind, transport)
+                    endpoint.libStart()
+                    endpoint.audDevManager().setNullDev()
+                    configure_codecs(endpoint)
+                    ac = pj.AccountConfig()
+                    ac.idUri = data["from"]
+                    ac.sipConfig.proxies.append("sip:" + data["endpoint"] + ";lr;transport=" + data.get("transport", "udp"))
+                    if data.get("username"):
+                        ac.sipConfig.authCreds.append(pj.AuthCredInfo("digest", "*", data["username"], 0, data.get("password", "")))
+                    account = pj.Account()
+                    account.create(ac)
+                elif action == "call":
+                    if call and not call.disconnected:
+                        raise ValueError("Already in a call; hang up before dialing again")
+                    if call:
+                        call.finish_recording()
+                    call = Call(account, endpoint, options["directory"], data["sessionId"])
+                    protocol.write(json.dumps({"event": "operation_started", "id": data["id"],
+                                               "offset": 0}) + "\n")
+                    uri = data["destination"]
+                    if not uri.startswith("sip:"):
+                        uri = "sip:" + uri + "@" + options["endpoint"]
+                    params = pj.CallOpParam(True)
+                    params.opt.audioCount = 1
+                    params.opt.videoCount = 0
+                    call.makeCall(uri, params)
+                    wait(lambda: call.connected and call.media is not None, options.get("timeoutMs", 30000) / 1000, live=True)
+                elif action == "say":
+                    if not call or not call.connected or call.media is None:
+                        raise ValueError("No connected call; call() before say()")
+                    with tempfile.TemporaryDirectory(prefix="spectest-phone-") as tmp:
+                        path = os.path.join(tmp, "speech.wav")
+                        future = executor.submit(synthesize, data, options, path)
+                        wait(future.done, 110, live=True)
+                        result = future.result()
+                        player = Player()
+                        player.createPlayer(path, pj.PJMEDIA_FILE_NO_LOOP)
+                        media = call.media
+                        # Mix what we actually send with the incoming stream in
+                        # the same continuously clocked recorder.
+                        speech_offset = call.recorder.offset
+                        player.startTransmit(call.recorder)
+                        player.startTransmit(call.caller_meter)
+                        player.startTransmit(media)
+                        # Report immediately so interrupted/failed playback also
+                        # keeps its true start. This is relative to the recorder,
+                        # measured in recorded PCM frames, not elapsed wall time.
+                        protocol.write(json.dumps({"event": "speech_started", "id": data["id"],
+                                                   "sessionId": call.session_id, "offset": speech_offset}) + "\n")
+                        try:
+                            wait(lambda: player.done, result["duration"] + 5, live=True)
+                            result["offset"] = call.recorder.offset
+                        finally:
+                            player.stopTransmit(media)
+                            if call.recorder:
+                                player.stopTransmit(call.recorder)
+                                player.stopTransmit(call.caller_meter)
+                            del player
+                elif action == "wait_silence":
+                    if not call or call.disconnected or call.media is None:
+                        raise ValueError("No connected call; cannot wait for silence")
+                    silence = float(data["silenceMs"]) / 1000
+                    timeout = float(data["timeoutMs"]) / 1000
+                    if not math.isfinite(silence) or not math.isfinite(timeout) or silence <= 0 or timeout <= 0:
+                        raise ValueError("Silence duration and timeout must be positive")
+                    # A fresh quiet window starts AFTER the application predicate
+                    # succeeds; quiet heard before that does not satisfy this wait.
+                    began = time.monotonic()
+                    wait(lambda: time.monotonic() - max(began, call.incoming.last_voice) >= silence,
+                         timeout, live=True)
+                    result["offset"] = call.recorder.offset
+                elif action == "position":
+                    if not call:
+                        raise ValueError("No call recording")
+                    result["offset"] = call.recorder.offset
+                elif action == "hangup":
+                    hangup()
+                    if call:
+                        call.finish_recording()
+                else:
+                    raise ValueError("Unknown phone operation")
+                protocol.write(json.dumps({"id": data["id"], **result}) + "\n")
+            except EOFError:
+                raise
+            except Exception as error:
+                # PJSIP error.info() may include SIP identities; report status only.
+                message = str(error) if isinstance(error, ValueError) else f"Phone {data['action']} failed ({type(error).__name__})"
+                if call:
+                    result["offset"] = call.recorder.offset
+                protocol.write(json.dumps({"id": data["id"], **result, "error": message}) + "\n")
+    except EOFError:
+        pass
+    finally:
+        if call and not call.disconnected:
+            try:
+                call.hangup(pj.CallOpParam())
+                for _ in range(20):
+                    endpoint.libHandleEvents(10)
+            except Exception:
+                pass
+        if call:
+            call.finish_recording()
+        call = None
+        if account:
+            account.shutdown()
+            account = None
+        if endpoint:
+            endpoint.libDestroy()
+        executor.shutdown(wait=False, cancel_futures=True)
+
+
+if __name__ == "__main__":
+    main()

package/dist/harness/phone_recording.py

@@ -0,0 +1,95 @@
+"""Continuous Opus capture. No encoder I/O runs on the SIP media callback."""
+from array import array
+import os
+import queue
+import subprocess
+import threading
+import time
+
+MEDIA_RATE = 48000
+PEAK_SAMPLES = MEDIA_RATE // 20
+
+
+class StreamingRecording:
+    def __init__(self, path):
+        self.path = path
+        self.peaks = []
+        self.frames = 0
+        self.error = None
+        self.closed = threading.Event()
+        # Two seconds of 20ms PCM frames. A stalled encoder fails capture
+        # explicitly instead of blocking SIP or silently dropping audio.
+        self.pending = queue.Queue(maxsize=100)
+        self.encoder = subprocess.Popen([
+            os.environ.get("SPECTEST_PHONE_FFMPEG", "ffmpeg"),
+            "-nostdin", "-hide_banner", "-loglevel", "error", "-y",
+            "-f", "s16le", "-ar", str(MEDIA_RATE), "-ac", "1", "-i", "pipe:0",
+            "-map_metadata", "-1", "-c:a", "libopus", "-b:a", "48k",
+            "-vbr", "on", "-application", "audio", "-threads", "1",
+            "-f", "webm", path,
+        ], stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        self.writer = threading.Thread(target=self._encode, daemon=True)
+        self.writer.start()
+
+    def write(self, pcm):
+        if self.closed.is_set() or self.error:
+            return
+        try:
+            self.pending.put_nowait(pcm)
+        except queue.Full:
+            self.error = "Phone recording encoder could not keep up with audio"
+
+    def _encode(self):
+        try:
+            while not self.closed.is_set() or not self.pending.empty():
+                try:
+                    pcm = self.pending.get(timeout=0.02)
+                except queue.Empty:
+                    continue
+                samples = array("h", pcm)
+                # Accumulate exact 50ms peaks before compression, including
+                # windows split across the media callback's 20ms frames.
+                offset = 0
+                while offset < len(samples):
+                    index = self.frames // PEAK_SAMPLES
+                    count = min(PEAK_SAMPLES - self.frames % PEAK_SAMPLES, len(samples) - offset)
+                    part = samples[offset:offset + count]
+                    peak = round(max(abs(min(part)), abs(max(part))) / 32768, 4)
+                    if index == len(self.peaks):
+                        self.peaks.append(peak)
+                    else:
+                        self.peaks[index] = max(self.peaks[index], peak)
+                    offset += count
+                    self.frames += count
+                self.encoder.stdin.write(pcm)
+            self.encoder.stdin.close()
+            if self.encoder.wait(timeout=2) != 0:
+                self.error = "Phone recording encoder failed"
+        except Exception:
+            self.error = "Phone recording encoder failed"
+        finally:
+            if self.encoder.poll() is None:
+                self.encoder.kill()
+            self.encoder.wait()
+            try:
+                self.encoder.stdin.close()
+            except OSError:
+                pass
+
+    def finish(self):
+        started = time.monotonic()
+        self.closed.set()
+        self.writer.join(timeout=5)
+        if self.writer.is_alive():
+            self.error = "Phone recording encoder did not finish"
+            self.encoder.kill()
+            self.writer.join(timeout=1)
+        if self.error:
+            raise RuntimeError(self.error)
+        return {
+            "duration": self.frames / MEDIA_RATE,
+            "bytes": os.path.getsize(self.path),
+            "peaks": self.peaks,
+            "contentType": "audio/webm",
+            "encodingFinalizeMs": round((time.monotonic() - started) * 1000, 1),
+        }

package/dist/harness/protocol.d.ts

@@ -23,7 +23,7 @@
 /** Protocol version this build speaks. Must match `PROTOCOL_VERSION` in protocol.rs. */
 export declare const PROTOCOL_VERSION = 1;
 /** Methods either side can send. */
-export type Method = "hello" | "load" | "loadTests" | "fingerprint" | "bootstrap" | "interactiveSetup" | "run" | "eval" | "setRecordSecrets" | "teardown" | "shutdown" | "createArtifact" | "completeArtifact" | "progress" | "step";
+export type Method = "hello" | "load" | "loadTests" | "fingerprint" | "bootstrap" | "interactiveSetup" | "run" | "fakeFunctions" | "eval" | "setRecordSecrets" | "teardown" | "shutdown" | "createArtifact" | "completeArtifact" | "progress" | "step";
 /** Methods this build knows how to dispatch. A method outside this set still
  *  *parses* — it is answered with an error, never dropped. */
 export declare const KNOWN_METHODS: ReadonlySet<string>;

package/dist/harness/protocol.js

@@ -32,6 +32,7 @@ export const KNOWN_METHODS = new Set([
     "bootstrap",
     "interactiveSetup",
     "run",
+    "fakeFunctions",
     "eval",
     "setRecordSecrets",
     "teardown",

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export type { Phone, PhoneOptions, CallOptions, SpeechOptions } from "./phone.js";
+import type { Phone, PhoneOptions } from "./phone.js";
 import type { Android, AndroidApp } from "./android.js";
 export type { Android, AndroidApp, AndroidElement, AndroidRecordingOptions } from "./android.js";
 import { strict as nodeAssert } from "node:assert";
@@ -1283,6 +1285,12 @@ export interface TestContext<P = undefined, S extends ServicesMap = ServicesMap,
      * That is what makes "this tool is protected" a test.
      */
     mcp(url: string, opts?: McpOptions): Promise<Mcp>;
+    /**
+     * Open a SIP phone connected to a service in the environment. Both sides
+     * are recorded continuously for the whole call, including pauses between
+     * operations. Calls close and recordings finalize at case end.
+     */
+    phone(options: PhoneOptions): Promise<Phone>;
     /**
      * Open the headless browser. Backed by Chromium-over-CDP inside the VM.
      *

package/dist/phone.d.ts

@@ -0,0 +1,59 @@
+export interface PhoneOptions {
+    /** SIP server in the environment, e.g. sip:5060. */
+    endpoint: string;
+    /** Caller identity, e.g. sip:+46700000000@spectest.test. */
+    from: string;
+    transport?: "udp" | "tcp";
+    username?: string;
+    password?: string;
+    language?: string;
+    voice?: "M1" | "M2" | "M3" | "M4" | "M5" | "F1" | "F2" | "F3" | "F4" | "F5";
+    timeoutMs?: number;
+}
+export interface CallOptions {
+    /** Poll until true or a nonempty transcript string, then wait for incoming silence.
+     * A returned string is displayed as this step's recipient response. */
+    waitFor?: () => boolean | string | Promise<boolean | string>;
+}
+export interface SpeechOptions extends CallOptions {
+    language?: string;
+    voice?: PhoneOptions["voice"];
+    speed?: number;
+}
+export interface Phone {
+    /** Connect, optionally wait for a predicate then silence, and record one step. */
+    call(destination: string, options?: CallOptions): Promise<void>;
+    /** Send the complete utterance, optionally wait for a predicate then silence, and record one isolated step. */
+    say(text: string, options?: SpeechOptions): Promise<void>;
+    hangup(): Promise<void>;
+    /** Close the phone; also performed on success, failure, and test timeout. */
+    close(): Promise<void>;
+}
+/** Metadata only. Audio remains on disk until pulled through phoneRecordingChunk. */
+export interface PhoneRecording {
+    id: string;
+    startedAtMs: number;
+    duration: number;
+    bytes: number;
+    contentType: "audio/webm";
+    encodingFinalizeMs?: number;
+    peaks: number[];
+    callerPeaks?: number[];
+    recipientPeaks?: number[];
+    error?: string;
+}
+export declare function phoneRecordingChunk(id: string, offset: unknown, limit: unknown): Promise<{
+    b64: string;
+    offset: number;
+    total: number;
+}>;
+export declare function releasePhoneRecording(id: string): Promise<{
+    released: boolean;
+}>;
+export declare function phoneScope(caseStart?: number, { record }?: {
+    record?: boolean | undefined;
+}): {
+    open(options: PhoneOptions): Promise<Phone>;
+    close(): Promise<void>;
+    finish(): Promise<PhoneRecording[]>;
+};