assemblyai 4.35.3 → 4.36.3

package/dist/streaming.browser.mjs

@@ -584,6 +584,10 @@ class StreamingTranscriber {
         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.");
@@ -609,10 +613,12 @@ class StreamingTranscriber {
                 "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)]));
@@ -630,7 +636,9 @@ class StreamingTranscriber {
         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());
         }
@@ -1304,7 +1312,7 @@ if (typeof navigator !== "undefined" && navigator.userAgent) {
     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) {
@@ -1343,12 +1351,15 @@ class BaseService {
             this.userAgent = buildUserAgent(params.userAgent || {});
         }
     }
-    async fetch(input, init) {
+    async fetchResponse(input, init) {
         init = { ...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?.headers)
             headers = { ...headers, ...DEFAULT_FETCH_INIT.headers };
         if (init?.headers)
@@ -1358,15 +1369,17 @@ class BaseService {
             {
                 // 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 = await fetch(input, init);
+        return await fetch(input, init);
+    }
+    async fetch(input, init) {
+        const response = await this.fetchResponse(input, init);
         if (response.status >= 400) {
             let json;
             const text = await response.text();

package/dist/streaming.cjs

@@ -630,6 +630,10 @@ class StreamingTranscriber {
         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.");
@@ -655,10 +659,12 @@ class StreamingTranscriber {
                 "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)]));
@@ -677,7 +683,9 @@ class StreamingTranscriber {
         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());
         }
@@ -1395,13 +1403,16 @@ class BaseService {
             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)
@@ -1411,15 +1422,19 @@ class BaseService {
                 {
                     // 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();

package/dist/streaming.mjs

@@ -628,6 +628,10 @@ class StreamingTranscriber {
         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.");
@@ -653,10 +657,12 @@ class StreamingTranscriber {
                 "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)]));
@@ -675,7 +681,9 @@ class StreamingTranscriber {
         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());
         }
@@ -1393,13 +1401,16 @@ class BaseService {
             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)
@@ -1409,15 +1420,19 @@ class BaseService {
                 {
                     // 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();

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./sync";
 export * from "./files";
 export * from "./transcripts";
 export * from "./realtime";

package/dist/types/services/index.d.ts

@@ -3,6 +3,7 @@ type BaseServiceParams = {
     apiKey: string;
     baseUrl?: string;
     streamingBaseUrl?: string;
+    syncBaseUrl?: string;
     /**
      * The AssemblyAI user agent to use for requests.
      * The provided components will be merged into the default AssemblyAI user agent.

package/dist/types/streaming/index.d.ts

@@ -87,7 +87,12 @@ export type StreamingTranscriberParams = {
      * Milliseconds to wait between connection attempts. Defaults to 500.
      */
     connectionRetryDelay?: number;
-    sampleRate: number;
+    /**
+     * Required for PCM encodings (and for dual-channel mode). May be omitted
+     * for Opus encodings (`opus`, `ogg_opus`) — the stream is self-describing
+     * and the server ignores the value.
+     */
+    sampleRate?: number;
     encoding?: AudioEncoding;
     endOfTurnConfidenceThreshold?: number;
     /**

package/dist/types/sync/index.d.ts

@@ -0,0 +1,133 @@
+/// <reference types="node" />
+import { LiteralUnion } from "../helpers";
+/**
+ * The speech models available on the synchronous transcription API.
+ */
+export type SyncSpeechModel = LiteralUnion<"universal-3-5-pro", string>;
+/**
+ * The default speech model for synchronous transcription.
+ */
+export declare const defaultSyncSpeechModel: SyncSpeechModel;
+/**
+ * Audio input for synchronous transcription: a local file path or
+ * data URL (file system access requires Node.js, Bun, or Deno), raw audio
+ * bytes, a Blob/File, or a readable stream.
+ *
+ * URLs are not accepted — the sync API has no URL ingestion; use
+ * `client.transcripts` for URL or asynchronous transcription.
+ */
+export type SyncAudioInput = string | Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array> | NodeJS.ReadableStream;
+/**
+ * Options for a synchronous transcription request.
+ *
+ * `sample_rate` and `channels` are required only for raw PCM audio — WAV
+ * carries them in its header. `model` is sent as the `X-AAI-Model` routing
+ * header and is never included in the request body.
+ */
+export type SyncTranscriptionConfig = {
+    /**
+     * The sync speech model to route to, sent as the `X-AAI-Model` header.
+     * Defaults to `"universal-3-5-pro"`.
+     */
+    model?: SyncSpeechModel;
+    /**
+     * Custom transcription instruction. Maximum 4096 characters — longer
+     * prompts are rejected.
+     */
+    prompt?: string;
+    /**
+     * Terms to bias the decoder towards. Whitespace is stripped and empty
+     * terms are dropped. Maximum 2048 characters in total — longer lists are
+     * rejected.
+     */
+    keyterms_prompt?: string[];
+    /**
+     * Prior turns from the same conversation, oldest first, most recent last.
+     * A single string is treated as one turn. Capped at 100 turns and 4096
+     * characters in total — over-cap context is trimmed (oldest turns dropped
+     * first), not rejected.
+     */
+    conversation_context?: string | string[];
+    /**
+     * ISO 639-1 codes for the language(s) of the audio — a single-element
+     * array (e.g. `["es"]`) for monolingual audio, or several codes (e.g.
+     * `["en", "es"]`) for multilingual audio. Ignored when `prompt` is set.
+     * Defaults to English.
+     */
+    language_codes?: string[];
+    /**
+     * The source sample rate in Hz. Required for raw PCM audio; ignored for
+     * WAV.
+     */
+    sample_rate?: number;
+    /**
+     * The channel count (1 for mono, 2 for stereo). Required for raw PCM
+     * audio; ignored for WAV.
+     */
+    channels?: number;
+    /**
+     * Whether to compute per-word `start`/`end` timestamps. When `true`,
+     * words carry accurate timestamps at a small latency cost. Defaults to
+     * `false`: no timestamps are returned.
+     */
+    timestamps?: boolean;
+};
+/**
+ * Client-side options for a synchronous transcription request.
+ * These are not sent to the server.
+ */
+export type SyncTranscribeOptions = {
+    /**
+     * The request timeout in milliseconds. Defaults to 60 000, which is kept
+     * above the server's 30 s deadline so the client doesn't race it.
+     */
+    timeout?: number;
+};
+/**
+ * A single word in a sync transcript.
+ *
+ * `start`/`end` are in milliseconds and present only when the request set
+ * `timestamps: true`; otherwise they are omitted.
+ */
+export type SyncWord = {
+    /** The text of the word. */
+    text: string;
+    /**
+     * The start time of the word in milliseconds. Absent unless `timestamps`
+     * was requested.
+     */
+    start?: number;
+    /**
+     * The end time of the word in milliseconds. Absent unless `timestamps`
+     * was requested.
+     */
+    end?: number;
+    /** The confidence score of the word, in the range 0-1. */
+    confidence: number;
+};
+/**
+ * The result of a synchronous transcription request.
+ */
+export type SyncTranscriptResponse = {
+    /** The full transcript text. */
+    text: string;
+    /**
+     * Per-word confidence, plus `start`/`end` timings when the request set
+     * `timestamps: true`.
+     */
+    words: SyncWord[];
+    /** The overall transcript confidence, in the range 0-1. */
+    confidence: number;
+    /** The total audio duration in milliseconds. */
+    audio_duration_ms: number;
+    /**
+     * The server-generated UUID for this request. Record it to correlate a
+     * request with support.
+     */
+    session_id: string;
+    /**
+     * The end-to-end server-side request time in milliseconds. `undefined`
+     * when the server predates the field.
+     */
+    request_time_ms?: number;
+};

package/dist/utils/errors/index.d.ts

@@ -1,2 +1,3 @@
+export { SyncTranscriptError } from "./sync";
 export { RealtimeError, RealtimeErrorType, RealtimeErrorMessages, } from "./realtime";
 export { StreamingError, StreamingErrorType, StreamingErrorMessages, } from "./streaming";

package/dist/utils/errors/sync.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Error thrown when a synchronous transcription request fails.
+ */
+export declare class SyncTranscriptError extends Error {
+    readonly status?: number | undefined;
+    readonly errorCode?: string | undefined;
+    readonly retryAfter?: number | undefined;
+    name: string;
+    /**
+     * 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: string, status?: number | undefined, errorCode?: string | undefined, retryAfter?: number | undefined);
+}