assemblyai 4.35.4 → 4.36.3

package/dist/streaming.cjs

@@ -1403,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)
@@ -1419,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

@@ -1401,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)
@@ -1417,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/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);
+}