@rimelabs/sdk 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/realtime/settings.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from "./types.js";
+import type { SessionSettings } from "./protocol.js";
+export declare function toolSettings(tools: readonly ToolDefinition[]): SessionSettings["tools"];
+/** Bounded policy changes used to resolve each reply's settings revision. */
+export declare class InterruptionPolicies {
+    private changes;
+    private current;
+    private lastRevision;
+    record(revision: number | null, interrupt: boolean): void;
+    resolve(revision: number | null | undefined): boolean;
+}

package/dist/realtime/settings.js

@@ -0,0 +1,142 @@
+import { RimeInputError, RimeResourceLimitError } from "../errors.js";
+function toolString(value) {
+    // Unicode mode matches lone surrogates without rejecting valid UTF-16 pairs.
+    if (/[\uD800-\uDFFF]/u.test(value))
+        throw new RimeInputError("Tool strings must be valid UTF-8");
+    return value;
+}
+/** Reject values that JSON.stringify would silently drop or change. */
+function copyJson(value) {
+    if (typeof value === "string")
+        return toolString(value);
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (Array.isArray(value))
+        return Array.from(value, copyJson);
+    if (value &&
+        typeof value === "object" &&
+        [Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            toolString(key),
+            copyJson(item),
+        ]));
+    throw new RimeInputError("Tool schemas must contain finite JSON values");
+}
+function fillerSettings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new RimeInputError("prismFiller must be a filler object");
+    const kind = value.type;
+    if (!["none", "text", "auto"].includes(kind))
+        throw new RimeInputError("Prism filler type must be none, text, or auto");
+    const field = kind === "text" ? "text" : kind === "auto" ? "instructions" : null;
+    if (Object.entries(value).some(([key, item]) => item !== undefined && key !== "type" && key !== field))
+        throw new RimeInputError("Prism filler has fields not allowed for its type");
+    const text = field === null ? undefined : value[field];
+    if (kind === "text" || text !== undefined) {
+        // Rust str::trim uses Unicode White_Space, which differs from JS trim.
+        if (typeof text !== "string" ||
+            !/\P{White_Space}/u.test(text) ||
+            [...text].length > 500)
+            throw new RimeInputError("Prism filler text must be nonblank and at most 500 characters");
+        // Unicode mode matches lone surrogates but preserves valid UTF-16 pairs.
+        if (/[\uD800-\uDFFF]/u.test(text))
+            throw new RimeInputError("Prism filler text must be valid UTF-8");
+    }
+    if (kind === "text")
+        return { type: "text", text: text };
+    if (kind === "auto")
+        return text === undefined
+            ? { type: "auto" }
+            : { type: "auto", instructions: text };
+    return { type: "none" };
+}
+export function toolSettings(tools) {
+    if (!Array.isArray(tools))
+        throw new RimeInputError("tools must be an array");
+    const names = new Set();
+    return tools.map((tool) => {
+        if (!tool ||
+            typeof tool !== "object" ||
+            typeof tool.name !== "string" ||
+            !/\P{White_Space}/u.test(tool.name) ||
+            [...tool.name].length > 4000 ||
+            names.has(tool.name))
+            throw new RimeInputError("Tool names must be nonblank, unique, and at most 4000 characters");
+        toolString(tool.name);
+        names.add(tool.name);
+        if (!tool.parameters ||
+            Array.isArray(tool.parameters) ||
+            typeof tool.parameters !== "object" ||
+            (tool.description !== undefined && typeof tool.description !== "string"))
+            throw new RimeInputError("Tool parameters must be a JSON object and description must be a string");
+        let parameters;
+        try {
+            parameters = copyJson(tool.parameters);
+        }
+        catch (error) {
+            if (error instanceof RimeInputError)
+                throw error;
+            throw new RimeInputError("Tool schemas must contain finite JSON values");
+        }
+        if (parameters === null ||
+            typeof parameters !== "object" ||
+            Array.isArray(parameters))
+            throw new RimeInputError("Tool parameters must be an object");
+        return {
+            type: "function",
+            ...(tool.prismFiller === undefined
+                ? {}
+                : { prism_filler: fillerSettings(tool.prismFiller) }),
+            function: {
+                name: tool.name,
+                description: toolString(tool.description ?? ""),
+                parameters,
+            },
+        };
+    });
+}
+/** Bounded policy changes used to resolve each reply's settings revision. */
+export class InterruptionPolicies {
+    changes = [];
+    current = true;
+    lastRevision = null;
+    record(revision, interrupt) {
+        const previous = this.changes.at(-1);
+        if (!previous) {
+            this.changes.push({ revision: revision ?? 0, interrupt });
+        }
+        else if (revision === null) {
+            if (interrupt !== this.current && !previous.unknown) {
+                // Earlier published revisions stay known; later ones are ambiguous
+                // until an acknowledgment supplies the new policy's revision.
+                this.changes.push({
+                    revision: this.lastRevision === null ? 0 : this.lastRevision + 1,
+                    interrupt,
+                    unknown: true,
+                });
+            }
+        }
+        else if (previous.unknown || interrupt !== this.current) {
+            this.changes.push({ revision, interrupt });
+        }
+        if (revision !== null)
+            this.lastRevision = revision;
+        if (this.changes.length > 128)
+            this.changes.shift();
+        this.current = interrupt;
+    }
+    resolve(revision) {
+        if (revision == null || this.changes.length === 0)
+            return this.current;
+        for (let i = this.changes.length - 1; i >= 0; i--) {
+            if (this.changes[i].revision <= revision) {
+                if (this.changes[i].unknown)
+                    throw new RimeResourceLimitError("Reply settings revision crosses an unreported interruption policy change");
+                return this.changes[i].interrupt;
+            }
+        }
+        throw new RimeResourceLimitError("Reply settings revision is no longer retained");
+    }
+}

package/dist/realtime/transport.d.ts

@@ -0,0 +1,16 @@
+import { RimeError } from "../errors.js";
+/** Private transport. The public declarations do not require ws types. */
+export declare class RealtimeConnection {
+    private readonly socket;
+    private readonly opened;
+    private readonly ended;
+    private closing;
+    private connected;
+    readonly ready: Promise<void>;
+    onMessage: (raw: string) => void;
+    onFailure: (error: RimeError) => void;
+    constructor(endpoint: string, authorization: string, requestId?: string);
+    private failure;
+    send(encoded: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/realtime/transport.js

@@ -0,0 +1,86 @@
+import WebSocket from "ws";
+import { RimeAuthenticationError, RimeStreamError, RimeUnavailableError, } from "../errors.js";
+import { Deferred } from "./async.js";
+/** Private transport. The public declarations do not require ws types. */
+export class RealtimeConnection {
+    socket;
+    opened = new Deferred();
+    ended = new Deferred();
+    closing = null;
+    connected = false;
+    ready = this.opened.promise;
+    onMessage = () => { };
+    onFailure = () => { };
+    constructor(endpoint, authorization, requestId) {
+        this.socket = new WebSocket(endpoint, {
+            headers: {
+                Authorization: authorization,
+                ...(requestId === undefined ? {} : { "x-request-id": requestId }),
+            },
+            followRedirects: false,
+            perMessageDeflate: false,
+            maxPayload: 1024 * 1024,
+        });
+        this.socket.on("open", () => {
+            this.connected = true;
+            this.opened.resolve();
+        });
+        this.socket.on("unexpected-response", (request, response) => {
+            const error = [401, 403].includes(response.statusCode ?? 0)
+                ? new RimeAuthenticationError("Realtime endpoint rejected credentials")
+                : new RimeUnavailableError("Realtime endpoint rejected the connection");
+            this.failure(error);
+            response.destroy();
+            request.destroy();
+            this.socket.terminate();
+        });
+        this.socket.on("error", () => this.failure(!this.connected
+            ? new RimeUnavailableError("Realtime handshake failed")
+            : new RimeStreamError("Invalid event or lost realtime connection")));
+        this.socket.on("message", (data, binary) => {
+            if (binary) {
+                this.failure(new RimeStreamError("Expected a JSON text event"));
+                return;
+            }
+            this.onMessage(data.toString());
+        });
+        this.socket.on("close", () => {
+            this.ended.resolve();
+            this.failure(new RimeStreamError("Realtime connection closed; reconnect is not automatic"));
+        });
+    }
+    failure(error) {
+        this.opened.reject(error);
+        this.onFailure(error);
+    }
+    send(encoded) {
+        return new Promise((resolve, reject) => {
+            this.socket.send(encoded, (error) => {
+                if (error)
+                    reject(new RimeStreamError("Realtime write failed; outcome unknown"));
+                else
+                    resolve();
+            });
+        });
+    }
+    close() {
+        if (!this.closing) {
+            this.closing = (async () => {
+                if (this.socket.readyState === WebSocket.CLOSED)
+                    return;
+                const timer = setTimeout(() => this.socket.terminate(), 2000);
+                try {
+                    if (this.socket.readyState === WebSocket.CONNECTING)
+                        this.socket.terminate();
+                    else
+                        this.socket.close();
+                    await this.ended.promise;
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            })();
+        }
+        return this.closing;
+    }
+}

package/dist/realtime/types.d.ts

@@ -0,0 +1,292 @@
+import type { PCMFormat } from "../pcm.js";
+export type { PCMFormat } from "../pcm.js";
+import { RimeError, RimeTimeoutError } from "../errors.js";
+export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+/** Your labels for replies, keys to strings, such as `{ step: "3" }`. Prism
+ * takes at most 16, keys up to 64 characters and values up to 512, and
+ * refuses keys starting with `prism_`. */
+export type Labels = Readonly<Record<string, string>>;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+/** All durations are positive, finite seconds. */
+export interface RealtimeTimeouts {
+    readonly connectS?: number;
+    readonly readyS?: number;
+    readonly requestS?: number;
+}
+export interface RealtimeOperationOptions {
+    readonly signal?: AbortSignal;
+}
+/** Speech while a tool runs. Text and instructions must be nonblank and at
+ * most 500 Unicode scalar values. Invalid UTF-8 is rejected.
+ * Omit the setting to use the server default. */
+export type PrismFiller = {
+    readonly type: "none";
+    readonly text?: never;
+    readonly instructions?: never;
+} | {
+    readonly type: "text";
+    readonly text: string;
+    readonly instructions?: never;
+} | {
+    readonly type: "auto";
+    readonly instructions?: string;
+    readonly text?: never;
+};
+export interface ToolDefinition {
+    readonly name: string;
+    readonly parameters: JsonObject;
+    readonly description?: string;
+    readonly prismFiller?: PrismFiller;
+}
+export type TurnEagerness = "low" | "medium" | "high" | "auto";
+/** Omitted fields use the server's turn timing defaults. */
+export interface TurnDetection {
+    /** How readily Prism decides that the user has finished speaking. */
+    readonly eagerness?: TurnEagerness;
+    /** Maximum silence before ending a turn: an integer from 1000 to 10000 ms. */
+    readonly endOfTurnTimeoutMs?: number;
+}
+/** Effective server settings. Null means the server did not publish the field. */
+export interface TurnDetectionInfo {
+    readonly eagerness: TurnEagerness | "unknown" | null;
+    readonly endOfTurnTimeoutMs: number | null;
+}
+export interface RealtimeConnectOptions extends RealtimeOperationOptions {
+    /** Defaults to wss://prism.api.rime.ai/v1/realtime. */
+    readonly endpoint?: string;
+    readonly model?: "prism";
+    readonly voice?: string | null;
+    readonly instructions?: string | null;
+    readonly tools?: readonly ToolDefinition[];
+    readonly interruptOnSpeech?: boolean;
+    readonly turnDetection?: TurnDetection;
+    readonly timeouts?: RealtimeTimeouts;
+    /** Sent as the upgrade's `x-request-id`. It must be nonblank printable ASCII, or
+     * `connect` throws `RimeInputError`. Prism uses it if it is at most 128
+     * characters, else makes its own; `info.requestId` reports the one it used.
+     * Omitted or `null` sends none. */
+    readonly requestId?: string | null;
+    /** Labels every reply's `response.started` carries in `metadata`, such as
+     * `{ step: "3" }`; change them with `session.setResponseMetadata`. Prism
+     * refuses keys starting with `prism_`. Omitted or `null` sets none. */
+    readonly responseMetadata?: Labels | null;
+}
+/** Omitted fields keep their values. Empty instructions or tools clear them. */
+export interface RealtimeUpdateOptions extends RealtimeOperationOptions {
+    readonly instructions?: string;
+    readonly tools?: readonly ToolDefinition[];
+    readonly voice?: string;
+    readonly interruptOnSpeech?: boolean;
+}
+export interface ReplyOptions extends RealtimeOperationOptions {
+    readonly instruction?: string | null;
+    readonly toolCall?: ToolCallRef | null;
+}
+export interface AudioChunk {
+    readonly data: Uint8Array;
+    readonly format?: PCMFormat;
+}
+export interface ResponseRef {
+    readonly sessionId: string;
+    readonly responseId: string;
+}
+export interface ItemRef {
+    readonly sessionId: string;
+    readonly itemId: string;
+}
+export interface ToolCallRef extends ResponseRef {
+    readonly callId: string;
+}
+export interface OutputRef {
+    readonly response: ResponseRef;
+    readonly itemId: string;
+    readonly outputIndex: number;
+    readonly contentIndex: number;
+}
+export interface SessionInfo {
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
+    readonly sessionId: string;
+    /** The `x-request-id` Prism's logs name this session by. Null when the
+     * server does not publish it. */
+    readonly requestId: string | null;
+    /** The labels replies carry, as Prism last confirmed them. Null when the
+     * server does not publish them. */
+    readonly responseMetadata: Labels | null;
+    readonly model: "prism";
+    readonly voice: string;
+    readonly interruptOnSpeech: boolean;
+    readonly toolResultTimeoutS: number | null;
+    readonly toolContinuationTimeoutS: number | null;
+    readonly turnDetection: TurnDetectionInfo;
+}
+export interface RealtimeFault {
+    readonly code: string;
+    /** Optional for compatibility with caller-created faults. The SDK derives
+     * its output classification from the code and ignores supplied values. */
+    readonly retryable?: boolean;
+    readonly message: string;
+    readonly scope: "event" | "utterance" | "response" | "tool_roundtrip" | "session" | "unknown";
+    readonly requestId: string | null;
+    readonly responseId: string | null;
+    readonly itemId: string | null;
+    readonly callIds: readonly string[];
+    readonly correlationId: string | null;
+    readonly parameter: string | null;
+}
+/** An immutable fault produced by the SDK. */
+export interface NormalizedRealtimeFault extends RealtimeFault {
+    /** Whether the same request, unchanged, may succeed on another attempt.
+     * True only for capacity_exceeded, unavailable, and response_timeout.
+     * Unknown codes return false. The application owns retry timing, limits,
+     * and recovery after partial output; this value does not replay a request. */
+    readonly retryable: boolean;
+}
+export declare class RealtimeAdmissionTimeout extends RimeTimeoutError {
+}
+export declare class RimeRealtimeError extends RimeError {
+    readonly fault: NormalizedRealtimeFault;
+    constructor(fault: RealtimeFault);
+}
+export interface InputReady {
+    readonly kind: "input.ready";
+}
+/** The user may have started speaking over a playing reply. Prism sends it
+ * before `speech.started` when it may interrupt the reply; it can be a false
+ * alarm, so lower playback on it rather than stopping. */
+export interface SpeechHint {
+    readonly kind: "speech.hint";
+    readonly audioStartMs: number;
+}
+export interface SpeechStarted {
+    readonly kind: "speech.started";
+    readonly itemId: string;
+    readonly audioStartMs: number;
+}
+/** What ended the user's turn:
+ * - `semantic`: Prism judged from the user's speech that they had finished;
+ *   `eagerness` sets how readily it does.
+ * - `timeout`: the user was silent for `endOfTurnTimeoutMs`, and the timeout
+ *   ended the turn before Prism judged that they had finished.
+ * - `silence`: Prism's backup turn detection ended the turn at a short pause;
+ *   it does not apply `eagerness` or `endOfTurnTimeoutMs`.
+ * - `max_duration`: the user spoke for the longest turn Prism takes; what
+ *   they say next starts a new turn.
+ * - `detector_changed`: Prism switched between its main and backup turn
+ *   detection while the user spoke; nothing the user did ended the turn. */
+export type SpeechEndReason = "semantic" | "timeout" | "silence" | "max_duration" | "detector_changed";
+export interface SpeechStopped {
+    readonly kind: "speech.stopped";
+    readonly itemId: string;
+    readonly audioEndMs: number;
+    /** Null means the server did not publish the field. */
+    readonly endReason: SpeechEndReason | "unknown" | null;
+}
+export interface InputCommitted {
+    readonly kind: "input.committed";
+    readonly itemId: string;
+}
+export interface TranscriptDelta {
+    readonly kind: "transcript.delta";
+    readonly itemId: string;
+    readonly delta: string;
+}
+export interface TranscriptFinal {
+    readonly kind: "transcript.final";
+    readonly itemId: string;
+    readonly text: string;
+}
+export interface TranscriptFailed<Fault extends RealtimeFault = RealtimeFault> {
+    readonly kind: "transcript.failed";
+    readonly itemId: string;
+    readonly error: Fault;
+}
+export interface ResponseStarted {
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
+    readonly kind: "response.started";
+    readonly response: ResponseRef;
+    readonly cause: "speech" | "text" | "proactive" | "tools" | "unknown";
+    readonly parent: ResponseRef | null;
+    readonly inputItemId: string | null;
+    /** The session's labels when the reply began. Prism's `prism_` keys are
+     * left out. */
+    readonly metadata: Labels;
+    /** The user items the reply answers: a spoken reply's committed turns, or
+     * a typed turn's item. Empty when the server names none. */
+    readonly inputItemIds: readonly string[];
+}
+export interface MessageStarted {
+    readonly kind: "message.started";
+    readonly output: OutputRef;
+}
+export interface TextDelta {
+    readonly kind: "text.delta";
+    readonly output: OutputRef;
+    readonly delta: string;
+}
+export interface TextDone {
+    readonly kind: "text.done";
+    readonly output: OutputRef;
+    readonly text: string;
+}
+export interface AudioDelta {
+    readonly kind: "audio.delta";
+    readonly output: OutputRef;
+    readonly audio: {
+        readonly data: Uint8Array;
+        readonly format: Required<PCMFormat>;
+    };
+}
+export interface AudioDone {
+    readonly kind: "audio.done";
+    readonly output: OutputRef;
+}
+export interface ToolCall {
+    readonly kind: "tool.call";
+    readonly call: ToolCallRef;
+    readonly itemId: string;
+    readonly name: string;
+    readonly arguments: JsonObject;
+}
+export interface ResponseAbandoned {
+    readonly kind: "response.abandoned";
+    readonly response: ResponseRef;
+}
+export interface ResponseEnded {
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
+    readonly kind: "response.ended";
+    readonly response: ResponseRef;
+    readonly status: "completed" | "cancelled" | "failed" | "unknown";
+    readonly reason: string | null;
+}
+export interface FaultEvent<Fault extends RealtimeFault = RealtimeFault> {
+    readonly kind: "error";
+    readonly error: Fault;
+}
+export type InputEvent<Fault extends RealtimeFault = RealtimeFault> = InputReady | SpeechHint | SpeechStarted | SpeechStopped | InputCommitted | TranscriptDelta | TranscriptFinal | TranscriptFailed<Fault>;
+export type ResponseEvent = ResponseStarted | ResponseAbandoned | MessageStarted | TextDelta | TextDone | AudioDelta | AudioDone | ToolCall | ResponseEnded;
+export interface SessionEvent<Fault extends RealtimeFault = RealtimeFault> {
+    readonly sessionId: string;
+    readonly eventId: string;
+    readonly requestId: string | null;
+    readonly payload: InputEvent<Fault> | ResponseEvent | FaultEvent<Fault>;
+}
+export interface PlaybackInterrupted {
+    readonly kind: "interrupted";
+    readonly output: OutputRef;
+    readonly audioEndMs: number;
+}
+export interface PlaybackFinished {
+    readonly kind: "finished";
+    readonly response: ResponseRef;
+    readonly playedMs?: number | null;
+    readonly audibleTailMs?: number | null;
+}
+export type PlaybackReport = PlaybackInterrupted | PlaybackFinished;

package/dist/realtime/types.js

@@ -0,0 +1,12 @@
+import { RimeError, RimeTimeoutError } from "../errors.js";
+import { normalizeFault } from "./faults.js";
+export class RealtimeAdmissionTimeout extends RimeTimeoutError {
+}
+export class RimeRealtimeError extends RimeError {
+    fault;
+    constructor(fault) {
+        const normalized = normalizeFault(fault);
+        super(`${normalized.code}: ${normalized.message}`, normalized.requestId);
+        this.fault = normalized;
+    }
+}

package/dist/stt/audio.d.ts

@@ -0,0 +1,15 @@
+import { type PCMFormat } from "../pcm.js";
+/** One utterance of headerless signed PCM16 little-endian mono 16 kHz output.
+ * Fully consume each feed iterator before feeding the next chunk. Conversion
+ * advances one bounded source portion at a time so callers can apply backpressure.
+ */
+export declare class InputAudio {
+    private readonly converter;
+    private readonly frameBytes;
+    private pending;
+    private finished;
+    constructor(format?: PCMFormat);
+    feed(data: Uint8Array): Generator<Buffer>;
+    /** Check EOF before committing; never silently pad or truncate a final frame. */
+    finish(): void;
+}

package/dist/stt/audio.js

@@ -0,0 +1,46 @@
+import { RimeAudioFormatError, RimeInputError } from "../errors.js";
+import { InputConverter, resolvePCMFormat } from "../pcm.js";
+// Bound conversion work and temporary allocations for large source chunks.
+const sourceBytes = 16384;
+// Maximum decoded STT audio payload, excluding the protobuf envelope.
+const messageBytes = 65536;
+/** One utterance of headerless signed PCM16 little-endian mono 16 kHz output.
+ * Fully consume each feed iterator before feeding the next chunk. Conversion
+ * advances one bounded source portion at a time so callers can apply backpressure.
+ */
+export class InputAudio {
+    converter;
+    frameBytes;
+    pending = Buffer.alloc(0);
+    finished = false;
+    constructor(format) {
+        const resolved = resolvePCMFormat(format);
+        this.converter = new InputConverter(resolved);
+        this.frameBytes = 2 * resolved.channels;
+    }
+    *feed(data) {
+        if (this.finished)
+            throw new RimeInputError("The audio input is finished");
+        if (!(data instanceof Uint8Array))
+            throw new RimeAudioFormatError("The audio source must yield PCM16 Uint8Array chunks");
+        for (let offset = 0; offset < data.length; offset += sourceBytes) {
+            const part = Buffer.concat([
+                this.pending,
+                data.subarray(offset, offset + sourceBytes),
+            ]);
+            const complete = part.length - (part.length % this.frameBytes);
+            this.pending = Buffer.from(part.subarray(complete));
+            if (complete) {
+                const converted = this.converter.process(part.subarray(0, complete));
+                for (let start = 0; start < converted.length; start += messageBytes)
+                    yield converted.subarray(start, start + messageBytes);
+            }
+        }
+    }
+    /** Check EOF before committing; never silently pad or truncate a final frame. */
+    finish() {
+        this.finished = true;
+        if (this.pending.length)
+            throw new RimeAudioFormatError("The audio source ended with an incomplete PCM16 frame");
+    }
+}

package/dist/stt/client.d.ts

@@ -0,0 +1,17 @@
+import { Credentials } from "../auth.js";
+import { TranscriptStream } from "./stream.js";
+import type { AudioSource, TranscriptionOptions, TranscribeOptions, Transcription } from "./types.js";
+export declare class STT {
+    private readonly credentials;
+    private readonly checkOpen;
+    private connection;
+    private streams;
+    private readonly cancellation;
+    private readonly requests;
+    constructor(credentials: Credentials, checkOpen: () => void);
+    /** Transcribe complete WAV bytes (at most 16 MiB), without replay or retries. */
+    transcribe(audio: Uint8Array, options: TranscribeOptions): Promise<Transcription>;
+    private prepare;
+    stream(source: AudioSource, options: TranscriptionOptions): TranscriptStream;
+    close(): Promise<void>;
+}