assemblyai 4.35.3 → 4.36.3

package/dist/assemblyai.umd.js

@@ -4,6 +4,11 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.assemblyai = {}));
 })(this, (function (exports) { 'use strict';
 
+    /**
+     * The default speech model for synchronous transcription.
+     */
+    const defaultSyncSpeechModel = "universal-3-5-pro";
+
     /**
      * Thrown when `DualChannelCapture` is constructed in a non-browser environment
      * (no `globalThis.AudioContext`). The helper is intentionally surfaced from the
@@ -56,11 +61,39 @@
         });
     }
 
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
     typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
         var e = new Error(message);
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    const readFile = function (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Interacting with the file system is not supported in this environment.");
+        });
+    };
+
     const DEFAULT_FETCH_INIT = {
         cache: "no-store",
     };
@@ -78,7 +111,7 @@
         defaultUserAgentString += navigator.userAgent;
     }
     const defaultUserAgent = {
-        sdk: { name: "JavaScript", version: "4.35.3" },
+        sdk: { name: "JavaScript", version: "4.36.3" },
     };
     if (typeof process !== "undefined") {
         if (process.versions.node && defaultUserAgentString.indexOf("Node") === -1) {
@@ -117,13 +150,16 @@
                 this.userAgent = buildUserAgent(params.userAgent || {});
             }
         }
-        fetch(input, init) {
+        fetchResponse(input, init) {
             return __awaiter(this, void 0, void 0, function* () {
                 init = Object.assign(Object.assign({}, DEFAULT_FETCH_INIT), init);
                 let headers = {
                     Authorization: this.params.apiKey,
-                    "Content-Type": "application/json",
                 };
+                // FormData bodies must let fetch set the multipart boundary itself.
+                if (!(init.body instanceof FormData)) {
+                    headers["Content-Type"] = "application/json";
+                }
                 if (DEFAULT_FETCH_INIT === null || DEFAULT_FETCH_INIT === void 0 ? void 0 : DEFAULT_FETCH_INIT.headers)
                     headers = Object.assign(Object.assign({}, headers), DEFAULT_FETCH_INIT.headers);
                 if (init === null || init === void 0 ? void 0 : init.headers)
@@ -133,15 +169,19 @@
                     {
                         // chromium browsers have a bug where the user agent can't be modified
                         if (typeof window !== "undefined" && "chrome" in window) {
-                            headers["AssemblyAI-Agent"] =
-                                this.userAgent;
+                            headers["AssemblyAI-Agent"] = this.userAgent;
                         }
                     }
                 }
                 init.headers = headers;
                 if (!input.startsWith("http"))
                     input = this.params.baseUrl + input;
-                const response = yield fetch(input, init);
+                return yield fetch(input, init);
+            });
+        }
+        fetch(input, init) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.fetchResponse(input, init);
                 if (response.status >= 400) {
                     let json;
                     const text = yield response.text();
@@ -169,65 +209,373 @@
         }
     }
 
-    class LemurService extends BaseService {
-        summary(params, signal) {
-            return this.fetchJson("/lemur/v3/generate/summary", {
-                method: "POST",
-                body: JSON.stringify(params),
-                signal,
-            });
-        }
-        questionAnswer(params, signal) {
-            return this.fetchJson("/lemur/v3/generate/question-answer", {
-                method: "POST",
-                body: JSON.stringify(params),
-                signal,
-            });
+    /**
+     * Error thrown when a synchronous transcription request fails.
+     */
+    class SyncTranscriptError extends Error {
+        /**
+         * Create a new SyncTranscriptError.
+         * @param message - The human-readable error message.
+         * @param status - The HTTP status code of the failed request.
+         * @param errorCode - Machine-readable code — the snake_cased
+         * problem-details `title` from the server (e.g. `bad_audio`,
+         * `audio_too_large`, `capacity_exceeded`, `inference_timeout`).
+         * @param retryAfter - Seconds to wait before retrying, from the
+         * `Retry-After` header on 429/503 responses.
+         */
+        constructor(message, status, errorCode, retryAfter) {
+            super(message);
+            this.status = status;
+            this.errorCode = errorCode;
+            this.retryAfter = retryAfter;
+            this.name = "SyncTranscriptError";
         }
-        actionItems(params, signal) {
-            return this.fetchJson("/lemur/v3/generate/action-items", {
-                method: "POST",
-                body: JSON.stringify(params),
-                signal,
-            });
+    }
+
+    function getPath(path) {
+        if (path.startsWith("http"))
+            return null;
+        if (path.startsWith("https"))
+            return null;
+        if (path.startsWith("data:"))
+            return null;
+        if (path.startsWith("file://"))
+            return path.substring(7);
+        if (path.startsWith("file:"))
+            return path.substring(5);
+        return path;
+    }
+
+    // Canonical paths since the sync API gained a /v1 prefix (#18103); the
+    // unprefixed routes remain served for SDK versions that predate it.
+    const transcribeEndpoint = "/v1/transcribe";
+    const warmEndpoint = "/v1/warm";
+    const modelHeader = "X-AAI-Model";
+    // Kept above the server's 30 s deadline so the client doesn't race it.
+    const defaultTimeoutMs = 60000;
+    const warmTimeoutMs = 10000;
+    const maxPromptLength = 4096;
+    const maxKeytermsPromptLength = 2048;
+    const maxContextTurns = 100;
+    const maxContextLength = 4096;
+    // Extensions that signal raw S16LE PCM rather than a WAV container.
+    const pcmSuffixes = [".pcm", ".raw"];
+    /**
+     * The synchronous transcription service: audio in, transcript out,
+     * one request.
+     *
+     * Unlike `client.transcripts` (which submits a job to the async API and
+     * polls for completion), `SyncTranscriber` posts the audio to the sync
+     * API and returns the finished transcript in the HTTP response. There is no
+     * job id or status to poll. Accepts a local file path, raw audio bytes, a
+     * Blob, or a readable stream — but not a URL.
+     */
+    class SyncTranscriber extends BaseService {
+        /**
+         * Create a new synchronous transcription service.
+         * @param params - The parameters to use for the service.
+         */
+        constructor(params) {
+            super(params);
         }
-        task(params, signal) {
-            return this.fetchJson("/lemur/v3/generate/task", {
-                method: "POST",
-                body: JSON.stringify(params),
-                signal,
+        /**
+         * Transcribe audio and return the finished transcript in one request.
+         * @param audio - A local file path, raw audio bytes, a Blob, or a readable
+         * stream. Raw PCM also requires `sample_rate` and `channels` on the config.
+         * @param config - Options for this transcription request.
+         * @param options - Client-side options, such as the request timeout.
+         * @returns A promise that resolves to the finished transcript.
+         * @throws SyncTranscriptError when the request fails.
+         */
+        transcribe(audio_1) {
+            return __awaiter(this, arguments, void 0, function* (audio, config = {}, options = {}) {
+                var _a, _b;
+                const { bytes, filename, contentType } = yield resolveAudio(audio, config);
+                const body = new FormData();
+                body.append("audio", new Blob([bytes], { type: contentType }), filename);
+                const configJson = buildConfigJson(config);
+                if (configJson) {
+                    body.append("config", new Blob([JSON.stringify(configJson)], { type: "application/json" }));
+                }
+                const response = yield this.fetchResponse(transcribeEndpoint, {
+                    method: "POST",
+                    body,
+                    headers: { [modelHeader]: (_a = config.model) !== null && _a !== void 0 ? _a : defaultSyncSpeechModel },
+                    signal: AbortSignal.timeout((_b = options.timeout) !== null && _b !== void 0 ? _b : defaultTimeoutMs),
+                });
+                if (response.status !== 200)
+                    throw yield errorFromResponse(response);
+                return (yield response.json());
             });
         }
-        getResponse(id, signal) {
-            return this.fetchJson(`/lemur/v3/${id}`, { signal });
-        }
         /**
-         * Delete the data for a previously submitted LeMUR request.
-         * @param id - ID of the LeMUR request
-         * @param signal - Optional AbortSignal to cancel the request
+         * Open the connection to the sync API ahead of time.
+         *
+         * The sync API is a single request/response, so a `transcribe()` that
+         * opens its connection on demand pays the full DNS + TCP + TLS handshake
+         * on the critical path. Call `warm()` as soon as you know audio is coming —
+         * typically while the clip is still being recorded — so the next
+         * `transcribe()` reuses the already-open connection. `warm()` is idempotent
+         * and cheap; call it shortly before `transcribe()` so the pooled connection
+         * hasn't idled out.
+         * @param params - Optionally the model to route the probe to, so the warmed
+         * connection lands on the same backend as the eventual transcription.
+         * @returns A promise that resolves to `true` once the connection is open
+         * (any HTTP response — even a non-200 — means the socket is
+         * established), or `false` if the connection could not be opened.
          */
-        purgeRequestData(id, signal) {
-            return this.fetchJson(`/lemur/v3/${id}`, {
-                method: "DELETE",
-                signal,
+        warm(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    yield this.fetchResponse(warmEndpoint, {
+                        method: "GET",
+                        headers: { [modelHeader]: (_a = params === null || params === void 0 ? void 0 : params.model) !== null && _a !== void 0 ? _a : defaultSyncSpeechModel },
+                        signal: AbortSignal.timeout(warmTimeoutMs),
+                    });
+                    return true;
+                }
+                catch (_b) {
+                    return false;
+                }
             });
         }
     }
-
-    const { WritableStream } = typeof window !== "undefined"
-        ? window
-        : typeof global !== "undefined"
-            ? global
-            : globalThis;
-
-    var _a, _b;
-    const PolyfillWebSocket = (_b = (_a = WebSocket !== null && WebSocket !== void 0 ? WebSocket : global === null || global === void 0 ? void 0 : global.WebSocket) !== null && _a !== void 0 ? _a : window === null || window === void 0 ? void 0 : window.WebSocket) !== null && _b !== void 0 ? _b : self === null || self === void 0 ? void 0 : self.WebSocket;
-    const factory = (url, params) => {
-        if (params) {
-            return new PolyfillWebSocket(url, params);
-        }
-        return new PolyfillWebSocket(url);
-    };
+    /**
+     * Read the audio input into bytes and decide its multipart content type.
+     *
+     * PCM is selected when the source has a `.pcm`/`.raw` extension or when
+     * `sample_rate`/`channels` are set on the config (the fields the sync API
+     * requires only for raw PCM) — and both must then be present. Everything
+     * else is treated as a WAV container. URLs are rejected — the sync API has
+     * no URL ingestion.
+     */
+    function resolveAudio(input, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let bytes;
+            let filename;
+            let suffix = "";
+            if (typeof input === "string") {
+                if (/^https?:\/\//i.test(input)) {
+                    throw new Error("SyncTranscriber does not accept URLs. Pass a local file path or " +
+                        "audio bytes, or use client.transcripts for URL/async transcription.");
+                }
+                if (input.startsWith("data:")) {
+                    bytes = dataUrlToBytes(input);
+                }
+                else {
+                    const path = (_a = getPath(input)) !== null && _a !== void 0 ? _a : input;
+                    bytes = yield readStream(yield readFile());
+                    filename = basename(path);
+                    suffix = extname(filename);
+                }
+            }
+            else if (input instanceof Uint8Array) {
+                bytes = input;
+            }
+            else if (input instanceof ArrayBuffer) {
+                bytes = new Uint8Array(input);
+            }
+            else if (input instanceof Blob) {
+                bytes = new Uint8Array(yield input.arrayBuffer());
+                // File instances carry a name; the File global itself needs Node >= 20.
+                const name = input.name;
+                if (name) {
+                    filename = basename(name);
+                    suffix = extname(filename);
+                }
+            }
+            else if (isWebReadableStream(input)) {
+                bytes = yield readStream(input);
+            }
+            else if (isAsyncIterable(input)) {
+                bytes = yield readAsyncIterable(input);
+                // fs.ReadStream carries the path it was opened from.
+                const path = input.path;
+                if (typeof path === "string") {
+                    filename = basename(path);
+                    suffix = extname(filename);
+                }
+            }
+            else {
+                throw new TypeError("unsupported audio input type");
+            }
+            const wantsPcm = config.sample_rate !== undefined || config.channels !== undefined;
+            const isPcm = pcmSuffixes.includes(suffix) || wantsPcm;
+            if (isPcm &&
+                (config.sample_rate === undefined || config.channels === undefined)) {
+                throw new Error("raw PCM audio requires both sample_rate and channels in the config");
+            }
+            const contentType = isPcm ? "audio/pcm" : "audio/wav";
+            if (!filename)
+                filename = isPcm ? "audio.pcm" : "audio.wav";
+            return { bytes, filename, contentType };
+        });
+    }
+    /**
+     * Serialize the config to the JSON `config` part, validating and normalizing
+     * field values to match the server's caps. The routing `model` is never
+     * included — it travels in the `X-AAI-Model` header. Returns `undefined`
+     * when there is nothing to send, so the part can be omitted entirely.
+     */
+    function buildConfigJson(config) {
+        if (config.prompt !== undefined && config.prompt.length > maxPromptLength) {
+            throw new Error(`prompt exceeds ${maxPromptLength} characters (got ${config.prompt.length})`);
+        }
+        const json = {};
+        if (config.prompt !== undefined)
+            json["prompt"] = config.prompt;
+        const keytermsPrompt = normalizeKeytermsPrompt(config.keyterms_prompt);
+        if (keytermsPrompt)
+            json["keyterms_prompt"] = keytermsPrompt;
+        const context = normalizeConversationContext(config.conversation_context);
+        if (context)
+            json["conversation_context"] = context;
+        if (config.language_codes !== undefined)
+            json["language_codes"] = config.language_codes;
+        if (config.sample_rate !== undefined)
+            json["sample_rate"] = config.sample_rate;
+        if (config.channels !== undefined)
+            json["channels"] = config.channels;
+        if (config.timestamps !== undefined)
+            json["timestamps"] = config.timestamps;
+        return Object.keys(json).length > 0 ? json : undefined;
+    }
+    function normalizeKeytermsPrompt(keytermsPrompt) {
+        if (!keytermsPrompt)
+            return undefined;
+        const terms = keytermsPrompt
+            .map((term) => term.trim())
+            .filter((term) => term.length > 0);
+        const total = terms.reduce((sum, term) => sum + term.length, 0);
+        if (total > maxKeytermsPromptLength) {
+            throw new Error(`keyterms_prompt exceeds ${maxKeytermsPromptLength} characters (got ${total})`);
+        }
+        return terms.length > 0 ? terms : undefined;
+    }
+    function normalizeConversationContext(context) {
+        if (context === undefined)
+            return undefined;
+        let turns = (typeof context === "string" ? [context] : context)
+            .map((turn) => turn.trim())
+            .filter((turn) => turn.length > 0);
+        let total = turns.reduce((sum, turn) => sum + turn.length, 0);
+        // Over-cap context is trimmed oldest-first, never rejected.
+        while (turns.length > 0 &&
+            (turns.length > maxContextTurns || total > maxContextLength)) {
+            total -= turns[0].length;
+            turns = turns.slice(1);
+        }
+        return turns.length > 0 ? turns : undefined;
+    }
+    /**
+     * Build a SyncTranscriptError from a non-200 response. The primary format
+     * is an RFC 9457 problem-details body (`status`/`title`/`detail`); legacy
+     * `{error_code, message}` and `{detail}`-only bodies are also accepted.
+     */
+    function errorFromResponse(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let errorCode;
+            let message;
+            const text = yield response.text();
+            try {
+                const body = JSON.parse(text);
+                if (body && typeof body === "object" && !Array.isArray(body)) {
+                    if (typeof body.error_code === "string")
+                        errorCode = body.error_code;
+                    if (errorCode === undefined && typeof body.title === "string") {
+                        errorCode = body.title.toLowerCase().replace(/ /g, "_");
+                    }
+                    if (typeof body.detail === "string")
+                        message = body.detail;
+                    else if (typeof body.message === "string")
+                        message = body.message;
+                }
+            }
+            catch (_a) {
+                if (text)
+                    message = text;
+            }
+            if (!message) {
+                message = `sync transcription failed with status ${response.status}`;
+            }
+            const retryHeader = response.headers.get("retry-after");
+            const retryAfter = retryHeader && /^\d+$/.test(retryHeader)
+                ? parseInt(retryHeader, 10)
+                : undefined;
+            return new SyncTranscriptError(message, response.status, errorCode, retryAfter);
+        });
+    }
+    function basename(path) {
+        var _a;
+        return (_a = path.split(/[\\/]/).pop()) !== null && _a !== void 0 ? _a : path;
+    }
+    function extname(filename) {
+        const dotIndex = filename.lastIndexOf(".");
+        return dotIndex > 0 ? filename.slice(dotIndex).toLowerCase() : "";
+    }
+    function dataUrlToBytes(dataUrl) {
+        const base64 = dataUrl.split(",")[1];
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return bytes;
+    }
+    function isWebReadableStream(input) {
+        return typeof (input === null || input === void 0 ? void 0 : input.getReader) === "function";
+    }
+    function isAsyncIterable(input) {
+        return (typeof (input === null || input === void 0 ? void 0 : input[Symbol.asyncIterator]) ===
+            "function");
+    }
+    function readStream(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunks = [];
+            const reader = stream.getReader();
+            for (;;) {
+                const { done, value } = yield reader.read();
+                if (done)
+                    break;
+                chunks.push(value);
+            }
+            return concatChunks(chunks);
+        });
+    }
+    function readAsyncIterable(iterable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, iterable_1, iterable_1_1;
+            var _b, e_1, _c, _d;
+            const chunks = [];
+            try {
+                for (_a = true, iterable_1 = __asyncValues(iterable); iterable_1_1 = yield iterable_1.next(), _b = iterable_1_1.done, !_b; _a = true) {
+                    _d = iterable_1_1.value;
+                    _a = false;
+                    const chunk = _d;
+                    chunks.push(chunk);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_a && !_b && (_c = iterable_1.return)) yield _c.call(iterable_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return concatChunks(chunks);
+        });
+    }
+    function concatChunks(chunks) {
+        const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const bytes = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return bytes;
+    }
 
     const RealtimeErrorType = {
         BadSampleRate: 4000,
@@ -333,6 +681,66 @@
     class StreamingError extends Error {
     }
 
+    class LemurService extends BaseService {
+        summary(params, signal) {
+            return this.fetchJson("/lemur/v3/generate/summary", {
+                method: "POST",
+                body: JSON.stringify(params),
+                signal,
+            });
+        }
+        questionAnswer(params, signal) {
+            return this.fetchJson("/lemur/v3/generate/question-answer", {
+                method: "POST",
+                body: JSON.stringify(params),
+                signal,
+            });
+        }
+        actionItems(params, signal) {
+            return this.fetchJson("/lemur/v3/generate/action-items", {
+                method: "POST",
+                body: JSON.stringify(params),
+                signal,
+            });
+        }
+        task(params, signal) {
+            return this.fetchJson("/lemur/v3/generate/task", {
+                method: "POST",
+                body: JSON.stringify(params),
+                signal,
+            });
+        }
+        getResponse(id, signal) {
+            return this.fetchJson(`/lemur/v3/${id}`, { signal });
+        }
+        /**
+         * Delete the data for a previously submitted LeMUR request.
+         * @param id - ID of the LeMUR request
+         * @param signal - Optional AbortSignal to cancel the request
+         */
+        purgeRequestData(id, signal) {
+            return this.fetchJson(`/lemur/v3/${id}`, {
+                method: "DELETE",
+                signal,
+            });
+        }
+    }
+
+    const { WritableStream } = typeof window !== "undefined"
+        ? window
+        : typeof global !== "undefined"
+            ? global
+            : globalThis;
+
+    var _a, _b;
+    const PolyfillWebSocket = (_b = (_a = WebSocket !== null && WebSocket !== void 0 ? WebSocket : global === null || global === void 0 ? void 0 : global.WebSocket) !== null && _a !== void 0 ? _a : window === null || window === void 0 ? void 0 : window.WebSocket) !== null && _b !== void 0 ? _b : self === null || self === void 0 ? void 0 : self.WebSocket;
+    const factory = (url, params) => {
+        if (params) {
+            return new PolyfillWebSocket(url, params);
+        }
+        return new PolyfillWebSocket(url);
+    };
+
     const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
     const forceEndOfUtteranceMessage = `{"force_end_utterance":true}`;
     const terminateSessionMessage$1 = `{"terminate_session":true}`;
@@ -590,20 +998,6 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
     class RealtimeServiceFactory extends RealtimeTranscriberFactory {
     }
 
-    function getPath(path) {
-        if (path.startsWith("http"))
-            return null;
-        if (path.startsWith("https"))
-            return null;
-        if (path.startsWith("data:"))
-            return null;
-        if (path.startsWith("file://"))
-            return path.substring(7);
-        if (path.startsWith("file:"))
-            return path.substring(5);
-        return path;
-    }
-
     class TranscriptService extends BaseService {
         constructor(params, files) {
             super(params);
@@ -850,14 +1244,6 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
         }
     }
 
-    const readFile = function (
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Interacting with the file system is not supported in this environment.");
-        });
-    };
-
     class FileService extends BaseService {
         /**
          * Upload a local file to AssemblyAI.
@@ -1141,6 +1527,10 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
             if (!(this.token || this.apiKey)) {
                 throw new Error("API key or temporary token is required.");
             }
+            const isOpus = params.encoding === "opus" || params.encoding === "ogg_opus";
+            if (params.sampleRate === undefined && (!isOpus || params.channels)) {
+                throw new Error('`sampleRate` is required; it may only be omitted when `encoding` is "opus" or "ogg_opus" (the Opus stream is self-describing) and dual-channel mode is not used.');
+            }
             if (params.channels) {
                 if (params.channels.length !== 2) {
                     throw new Error("StreamingTranscriber.channels must have exactly 2 entries.");
@@ -1166,10 +1556,12 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
                     "speaker-history") {
                     this.speakerHistory = new Map();
                 }
-                // 20 ms VAD frames at the transcriber's target sample rate.
-                this.vadFrameSamples = Math.max(1, Math.round(params.sampleRate * 0.02));
-                this.minChunkSamples = Math.max(1, Math.round(params.sampleRate * (MIN_CHUNK_MS / 1000)));
-                this.maxChunkSamples = Math.max(this.minChunkSamples, Math.round(params.sampleRate * (MAX_CHUNK_MS / 1000)));
+                // 20 ms VAD frames at the transcriber's target sample rate. The
+                // constructor check above guarantees sampleRate in dual-channel mode.
+                const sampleRate = params.sampleRate;
+                this.vadFrameSamples = Math.max(1, Math.round(sampleRate * 0.02));
+                this.minChunkSamples = Math.max(1, Math.round(sampleRate * (MIN_CHUNK_MS / 1000)));
+                this.maxChunkSamples = Math.max(this.minChunkSamples, Math.round(sampleRate * (MAX_CHUNK_MS / 1000)));
                 this.channelBuffers = new Map(names.map((n) => [n, []]));
                 this.channelSamplesReceived = new Map(names.map((n) => [n, 0]));
                 this.channelVadFloatBuffers = new Map(names.map((n) => [n, new Float32Array(this.vadFrameSamples)]));
@@ -1188,7 +1580,9 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
             if (this.token) {
                 searchParams.set("token", this.token);
             }
-            searchParams.set("sample_rate", this.params.sampleRate.toString());
+            if (this.params.sampleRate !== undefined) {
+                searchParams.set("sample_rate", this.params.sampleRate.toString());
+            }
             if (this.params.endOfTurnConfidenceThreshold) {
                 searchParams.set("end_of_turn_confidence_threshold", this.params.endOfTurnConfidenceThreshold.toString());
             }
@@ -2138,6 +2532,7 @@ registerProcessor("aai-pcm16-encoder", Pcm16EncoderProcessor);
 
     const defaultBaseUrl = "https://api.assemblyai.com";
     const defaultStreamingUrl = "https://streaming.assemblyai.com";
+    const defaultSyncUrl = "https://sync.assemblyai.com";
     class AssemblyAI {
         /**
          * Create a new AssemblyAI client.
@@ -2153,6 +2548,11 @@ registerProcessor("aai-pcm16-encoder", Pcm16EncoderProcessor);
             this.lemur = new LemurService(params);
             this.realtime = new RealtimeTranscriberFactory(params);
             this.streaming = new StreamingTranscriberFactory(Object.assign(Object.assign({}, params), { baseUrl: params.streamingBaseUrl || defaultStreamingUrl }));
+            let syncBaseUrl = params.syncBaseUrl || defaultSyncUrl;
+            if (syncBaseUrl.endsWith("/")) {
+                syncBaseUrl = syncBaseUrl.slice(0, -1);
+            }
+            this.sync = new SyncTranscriber(Object.assign(Object.assign({}, params), { baseUrl: syncBaseUrl }));
         }
     }
 
@@ -2168,10 +2568,13 @@ registerProcessor("aai-pcm16-encoder", Pcm16EncoderProcessor);
     exports.RealtimeTranscriber = RealtimeTranscriber;
     exports.RealtimeTranscriberFactory = RealtimeTranscriberFactory;
     exports.StreamingTranscriber = StreamingTranscriber;
+    exports.SyncTranscriber = SyncTranscriber;
+    exports.SyncTranscriptError = SyncTranscriptError;
     exports.TranscriptService = TranscriptService;
     exports.VadTimeline = VadTimeline;
     exports.attributeTurn = attributeTurn;
     exports.attributeWord = attributeWord;
+    exports.defaultSyncSpeechModel = defaultSyncSpeechModel;
     exports.float32ToPcm16 = float32ToPcm16;
     exports.rollUpTurnChannel = rollUpTurnChannel;