assemblyai 4.5.0-beta.0 → 4.5.0

package/dist/node.mjs

@@ -3,6 +3,45 @@ import ws from 'ws';
 import { createReadStream } from 'fs';
 import { Readable } from 'stream';
 
+const DEFAULT_FETCH_INIT = {
+    cache: "no-store",
+};
+
+const buildUserAgent = (userAgent) => defaultUserAgentString +
+    (userAgent === false
+        ? ""
+        : " AssemblyAI/1.0 (" +
+            Object.entries({ ...defaultUserAgent, ...userAgent })
+                .map(([key, item]) => item ? `${key}=${item.name}/${item.version}` : "")
+                .join(" ") +
+            ")");
+let defaultUserAgentString = "";
+if (typeof navigator !== "undefined" && navigator.userAgent) {
+    defaultUserAgentString += navigator.userAgent;
+}
+const defaultUserAgent = {
+    sdk: { name: "JavaScript", version: "4.5.0" },
+};
+if (typeof process !== "undefined") {
+    if (process.versions.node && defaultUserAgentString.indexOf("Node") === -1) {
+        defaultUserAgent.runtime_env = {
+            name: "Node",
+            version: process.versions.node,
+        };
+    }
+    if (process.versions.bun && defaultUserAgentString.indexOf("Bun") === -1) {
+        defaultUserAgent.runtime_env = {
+            name: "Bun",
+            version: process.versions.bun,
+        };
+    }
+}
+if (typeof Deno !== "undefined") {
+    if (process.versions.bun && defaultUserAgentString.indexOf("Deno") === -1) {
+        defaultUserAgent.runtime_env = { name: "Deno", version: Deno.version.deno };
+    }
+}
+
 /**
  * Base class for services that communicate with the API.
  */
@@ -13,15 +52,32 @@ class BaseService {
      */
     constructor(params) {
         this.params = params;
+        if (params.userAgent === false) {
+            this.userAgent = undefined;
+        }
+        else {
+            this.userAgent = buildUserAgent(params.userAgent || {});
+        }
     }
     async fetch(input, init) {
-        init = init ?? {};
-        init.headers = init.headers ?? {};
-        init.headers = {
+        init = { ...DEFAULT_FETCH_INIT, ...init };
+        let headers = {
             Authorization: this.params.apiKey,
             "Content-Type": "application/json",
-            ...init.headers,
         };
+        if (DEFAULT_FETCH_INIT?.headers)
+            headers = { ...headers, ...DEFAULT_FETCH_INIT.headers };
+        if (init?.headers)
+            headers = { ...headers, ...init.headers };
+        if (this.userAgent) {
+            headers["User-Agent"] = this.userAgent;
+            // 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;
+            }
+        }
+        init.headers = headers;
         if (!input.startsWith("http"))
             input = this.params.baseUrl + input;
         const response = await fetch(input, init);
@@ -74,6 +130,9 @@ class LemurService extends BaseService {
             body: JSON.stringify(params),
         });
     }
+    getResponse(id) {
+        return this.fetchJson(`/lemur/v3/${id}`);
+    }
     /**
      * Delete the data for a previously submitted LeMUR request.
      * @param id - ID of the LeMUR request
@@ -348,6 +407,8 @@ function getPath(path) {
         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:"))
@@ -389,8 +450,13 @@ class TranscriptService extends BaseService {
                     audioUrl = await this.files.upload(path);
                 }
                 else {
-                    // audio is not a local path, assume it's a URL
-                    audioUrl = audio;
+                    if (audio.startsWith("data:")) {
+                        audioUrl = await this.files.upload(audio);
+                    }
+                    else {
+                        // audio is not a local path, and not a data-URI, assume it's a normal URL
+                        audioUrl = audio;
+                    }
                 }
             }
             else {
@@ -541,13 +607,43 @@ class TranscriptService extends BaseService {
         return await response.text();
     }
     /**
-     * Retrieve redactions of a transcript.
+     * Retrieve the redacted audio URL of a transcript.
      * @param id - The identifier of the transcript.
-     * @returns A promise that resolves to the subtitles text.
+     * @returns A promise that resolves to the details of the redacted audio.
+     * @deprecated Use `redactedAudio` instead.
      */
     redactions(id) {
+        return this.redactedAudio(id);
+    }
+    /**
+     * Retrieve the redacted audio URL of a transcript.
+     * @param id - The identifier of the transcript.
+     * @returns A promise that resolves to the details of the redacted audio.
+     */
+    redactedAudio(id) {
         return this.fetchJson(`/v2/transcript/${id}/redacted-audio`);
     }
+    /**
+     * Retrieve the redacted audio file of a transcript.
+     * @param id - The identifier of the transcript.
+     * @returns A promise that resolves to the fetch HTTP response of the redacted audio file.
+     */
+    async redactedAudioFile(id) {
+        const { redacted_audio_url, status } = await this.redactedAudio(id);
+        if (status !== "redacted_audio_ready") {
+            throw new Error(`Redacted audio status is ${status}`);
+        }
+        const response = await fetch(redacted_audio_url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch redacted audio: ${response.statusText}`);
+        }
+        return {
+            arrayBuffer: response.arrayBuffer.bind(response),
+            blob: response.blob.bind(response),
+            body: response.body,
+            bodyUsed: response.bodyUsed,
+        };
+    }
 }
 function deprecateConformer2(params) {
     if (!params)
@@ -567,8 +663,14 @@ class FileService extends BaseService {
      */
     async upload(input) {
         let fileData;
-        if (typeof input === "string")
-            fileData = await readFile(input);
+        if (typeof input === "string") {
+            if (input.startsWith("data:")) {
+                fileData = dataUrlToBlob(input);
+            }
+            else {
+                fileData = await readFile(input);
+            }
+        }
         else
             fileData = input;
         const data = await this.fetchJson("/v2/upload", {
@@ -582,6 +684,17 @@ class FileService extends BaseService {
         return data.upload_url;
     }
 }
+function dataUrlToBlob(dataUrl) {
+    const arr = dataUrl.split(",");
+    const mime = arr[0].match(/:(.*?);/)[1];
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+        u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new Blob([u8arr], { type: mime });
+}
 
 const defaultBaseUrl = "https://api.assemblyai.com";
 class AssemblyAI {
@@ -591,8 +704,9 @@ class AssemblyAI {
      */
     constructor(params) {
         params.baseUrl = params.baseUrl || defaultBaseUrl;
-        if (params.baseUrl && params.baseUrl.endsWith("/"))
+        if (params.baseUrl && params.baseUrl.endsWith("/")) {
             params.baseUrl = params.baseUrl.slice(0, -1);
+        }
         this.files = new FileService(params);
         this.transcripts = new TranscriptService(params, this.files);
         this.lemur = new LemurService(params);

package/dist/polyfills/fetch/default.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_FETCH_INIT: Record<string, unknown>;

package/dist/polyfills/fetch/workerd.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_FETCH_INIT: Record<string, unknown>;

package/dist/services/base.d.ts

@@ -4,6 +4,7 @@ import { BaseServiceParams } from "..";
  */
 export declare abstract class BaseService {
     private params;
+    private userAgent;
     /**
      * Create a new service.
      * @param params - The parameters to use for the service.

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

@@ -1,10 +1,17 @@
-import { LemurSummaryParams, LemurActionItemsParams, LemurQuestionAnswerParams, LemurTaskParams, LemurSummaryResponse, LemurQuestionAnswerResponse, LemurActionItemsResponse, LemurTaskResponse, PurgeLemurRequestDataResponse } from "../..";
+import { LemurSummaryParams, LemurActionItemsParams, LemurQuestionAnswerParams, LemurTaskParams, LemurSummaryResponse, LemurQuestionAnswerResponse, LemurActionItemsResponse, LemurTaskResponse, PurgeLemurRequestDataResponse, LemurResponse } from "../..";
 import { BaseService } from "../base";
 export declare class LemurService extends BaseService {
     summary(params: LemurSummaryParams): Promise<LemurSummaryResponse>;
     questionAnswer(params: LemurQuestionAnswerParams): Promise<LemurQuestionAnswerResponse>;
     actionItems(params: LemurActionItemsParams): Promise<LemurActionItemsResponse>;
     task(params: LemurTaskParams): Promise<LemurTaskResponse>;
+    /**
+     * Retrieve a LeMUR response that was previously generated.
+     * @param id - The ID of the LeMUR request you previously made. This would be found in the response of the original request.
+     * @returns The LeMUR response.
+     */
+    getResponse<T extends LemurResponse>(id: string): Promise<T>;
+    getResponse(id: string): Promise<LemurResponse>;
     /**
      * Delete the data for a previously submitted LeMUR request.
      * @param id - ID of the LeMUR request

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

@@ -1,5 +1,5 @@
 import { BaseService } from "../base";
-import { ParagraphsResponse, SentencesResponse, Transcript, TranscriptList, TranscriptParams, CreateTranscriptOptions, SubtitleFormat, RedactedAudioResponse, ListTranscriptParams, WordSearchResponse, BaseServiceParams, PollingOptions, TranscribeParams, TranscribeOptions, SubmitParams } from "../..";
+import { ParagraphsResponse, SentencesResponse, Transcript, TranscriptList, TranscriptParams, CreateTranscriptOptions, SubtitleFormat, RedactedAudioResponse, ListTranscriptParams, WordSearchResponse, BaseServiceParams, PollingOptions, TranscribeParams, TranscribeOptions, SubmitParams, RedactedAudioFile } from "../..";
 import { FileService } from "../files";
 export declare class TranscriptService extends BaseService {
     private files;
@@ -78,9 +78,22 @@ export declare class TranscriptService extends BaseService {
      */
     subtitles(id: string, format?: SubtitleFormat, chars_per_caption?: number): Promise<string>;
     /**
-     * Retrieve redactions of a transcript.
+     * Retrieve the redacted audio URL of a transcript.
      * @param id - The identifier of the transcript.
-     * @returns A promise that resolves to the subtitles text.
+     * @returns A promise that resolves to the details of the redacted audio.
+     * @deprecated Use `redactedAudio` instead.
      */
     redactions(id: string): Promise<RedactedAudioResponse>;
+    /**
+     * Retrieve the redacted audio URL of a transcript.
+     * @param id - The identifier of the transcript.
+     * @returns A promise that resolves to the details of the redacted audio.
+     */
+    redactedAudio(id: string): Promise<RedactedAudioResponse>;
+    /**
+     * Retrieve the redacted audio file of a transcript.
+     * @param id - The identifier of the transcript.
+     * @returns A promise that resolves to the fetch HTTP response of the redacted audio file.
+     */
+    redactedAudioFile(id: string): Promise<RedactedAudioFile>;
 }

package/dist/streaming.browser.mjs

@@ -0,0 +1,239 @@
+const { WritableStream } = typeof window !== "undefined"
+    ? window
+    : typeof global !== "undefined"
+        ? global
+        : globalThis;
+
+const PolyfillWebSocket = WebSocket ?? global?.WebSocket ?? window?.WebSocket ?? self?.WebSocket;
+const factory = (url, params) => {
+    if (params) {
+        return new PolyfillWebSocket(url, params);
+    }
+    return new PolyfillWebSocket(url);
+};
+
+var RealtimeErrorType;
+(function (RealtimeErrorType) {
+    RealtimeErrorType[RealtimeErrorType["BadSampleRate"] = 4000] = "BadSampleRate";
+    RealtimeErrorType[RealtimeErrorType["AuthFailed"] = 4001] = "AuthFailed";
+    // Both InsufficientFunds and FreeAccount error use 4002
+    RealtimeErrorType[RealtimeErrorType["InsufficientFundsOrFreeAccount"] = 4002] = "InsufficientFundsOrFreeAccount";
+    RealtimeErrorType[RealtimeErrorType["NonexistentSessionId"] = 4004] = "NonexistentSessionId";
+    RealtimeErrorType[RealtimeErrorType["SessionExpired"] = 4008] = "SessionExpired";
+    RealtimeErrorType[RealtimeErrorType["ClosedSession"] = 4010] = "ClosedSession";
+    RealtimeErrorType[RealtimeErrorType["RateLimited"] = 4029] = "RateLimited";
+    RealtimeErrorType[RealtimeErrorType["UniqueSessionViolation"] = 4030] = "UniqueSessionViolation";
+    RealtimeErrorType[RealtimeErrorType["SessionTimeout"] = 4031] = "SessionTimeout";
+    RealtimeErrorType[RealtimeErrorType["AudioTooShort"] = 4032] = "AudioTooShort";
+    RealtimeErrorType[RealtimeErrorType["AudioTooLong"] = 4033] = "AudioTooLong";
+    RealtimeErrorType[RealtimeErrorType["BadJson"] = 4100] = "BadJson";
+    RealtimeErrorType[RealtimeErrorType["BadSchema"] = 4101] = "BadSchema";
+    RealtimeErrorType[RealtimeErrorType["TooManyStreams"] = 4102] = "TooManyStreams";
+    RealtimeErrorType[RealtimeErrorType["Reconnected"] = 4103] = "Reconnected";
+    RealtimeErrorType[RealtimeErrorType["ReconnectAttemptsExhausted"] = 1013] = "ReconnectAttemptsExhausted";
+})(RealtimeErrorType || (RealtimeErrorType = {}));
+const RealtimeErrorMessages = {
+    [RealtimeErrorType.BadSampleRate]: "Sample rate must be a positive integer",
+    [RealtimeErrorType.AuthFailed]: "Not Authorized",
+    [RealtimeErrorType.InsufficientFundsOrFreeAccount]: "Insufficient funds or you are using a free account. This feature is paid-only and requires you to add a credit card. Please visit https://assemblyai.com/dashboard/ to add a credit card to your account.",
+    [RealtimeErrorType.NonexistentSessionId]: "Session ID does not exist",
+    [RealtimeErrorType.SessionExpired]: "Session has expired",
+    [RealtimeErrorType.ClosedSession]: "Session is closed",
+    [RealtimeErrorType.RateLimited]: "Rate limited",
+    [RealtimeErrorType.UniqueSessionViolation]: "Unique session violation",
+    [RealtimeErrorType.SessionTimeout]: "Session Timeout",
+    [RealtimeErrorType.AudioTooShort]: "Audio too short",
+    [RealtimeErrorType.AudioTooLong]: "Audio too long",
+    [RealtimeErrorType.BadJson]: "Bad JSON",
+    [RealtimeErrorType.BadSchema]: "Bad schema",
+    [RealtimeErrorType.TooManyStreams]: "Too many streams",
+    [RealtimeErrorType.Reconnected]: "Reconnected",
+    [RealtimeErrorType.ReconnectAttemptsExhausted]: "Reconnect attempts exhausted",
+};
+class RealtimeError extends Error {
+}
+
+const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
+const forceEndOfUtteranceMessage = `{"force_end_utterance":true}`;
+const terminateSessionMessage = `{"terminate_session":true}`;
+class RealtimeTranscriber {
+    constructor(params) {
+        this.listeners = {};
+        this.realtimeUrl = params.realtimeUrl ?? defaultRealtimeUrl;
+        this.sampleRate = params.sampleRate ?? 16_000;
+        this.wordBoost = params.wordBoost;
+        this.encoding = params.encoding;
+        this.endUtteranceSilenceThreshold = params.endUtteranceSilenceThreshold;
+        this.disablePartialTranscripts = params.disablePartialTranscripts;
+        if ("token" in params && params.token)
+            this.token = params.token;
+        if ("apiKey" in params && params.apiKey)
+            this.apiKey = params.apiKey;
+        if (!(this.token || this.apiKey)) {
+            throw new Error("API key or temporary token is required.");
+        }
+    }
+    connectionUrl() {
+        const url = new URL(this.realtimeUrl);
+        if (url.protocol !== "wss:") {
+            throw new Error("Invalid protocol, must be wss");
+        }
+        const searchParams = new URLSearchParams();
+        if (this.token) {
+            searchParams.set("token", this.token);
+        }
+        searchParams.set("sample_rate", this.sampleRate.toString());
+        if (this.wordBoost && this.wordBoost.length > 0) {
+            searchParams.set("word_boost", JSON.stringify(this.wordBoost));
+        }
+        if (this.encoding) {
+            searchParams.set("encoding", this.encoding);
+        }
+        searchParams.set("enable_extra_session_information", "true");
+        if (this.disablePartialTranscripts) {
+            searchParams.set("disable_partial_transcripts", this.disablePartialTranscripts.toString());
+        }
+        url.search = searchParams.toString();
+        return url;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    on(event, listener) {
+        this.listeners[event] = listener;
+    }
+    connect() {
+        return new Promise((resolve) => {
+            if (this.socket) {
+                throw new Error("Already connected");
+            }
+            const url = this.connectionUrl();
+            if (this.token) {
+                this.socket = factory(url.toString());
+            }
+            else {
+                this.socket = factory(url.toString(), {
+                    headers: { Authorization: this.apiKey },
+                });
+            }
+            this.socket.binaryType = "arraybuffer";
+            this.socket.onopen = () => {
+                if (this.endUtteranceSilenceThreshold === undefined ||
+                    this.endUtteranceSilenceThreshold === null) {
+                    return;
+                }
+                this.configureEndUtteranceSilenceThreshold(this.endUtteranceSilenceThreshold);
+            };
+            this.socket.onclose = ({ code, reason }) => {
+                if (!reason) {
+                    if (code in RealtimeErrorType) {
+                        reason = RealtimeErrorMessages[code];
+                    }
+                }
+                this.listeners.close?.(code, reason);
+            };
+            this.socket.onerror = (event) => {
+                if (event.error)
+                    this.listeners.error?.(event.error);
+                else
+                    this.listeners.error?.(new Error(event.message));
+            };
+            this.socket.onmessage = ({ data }) => {
+                const message = JSON.parse(data.toString());
+                if ("error" in message) {
+                    this.listeners.error?.(new RealtimeError(message.error));
+                    return;
+                }
+                switch (message.message_type) {
+                    case "SessionBegins": {
+                        const openObject = {
+                            sessionId: message.session_id,
+                            expiresAt: new Date(message.expires_at),
+                        };
+                        resolve(openObject);
+                        this.listeners.open?.(openObject);
+                        break;
+                    }
+                    case "PartialTranscript": {
+                        // message.created is actually a string when coming from the socket
+                        message.created = new Date(message.created);
+                        this.listeners.transcript?.(message);
+                        this.listeners["transcript.partial"]?.(message);
+                        break;
+                    }
+                    case "FinalTranscript": {
+                        // message.created is actually a string when coming from the socket
+                        message.created = new Date(message.created);
+                        this.listeners.transcript?.(message);
+                        this.listeners["transcript.final"]?.(message);
+                        break;
+                    }
+                    case "SessionInformation": {
+                        this.listeners.session_information?.(message);
+                        break;
+                    }
+                    case "SessionTerminated": {
+                        this.sessionTerminatedResolve?.();
+                        break;
+                    }
+                }
+            };
+        });
+    }
+    sendAudio(audio) {
+        this.send(audio);
+    }
+    stream() {
+        return new WritableStream({
+            write: (chunk) => {
+                this.sendAudio(chunk);
+            },
+        });
+    }
+    /**
+     * Manually end an utterance
+     */
+    forceEndUtterance() {
+        this.send(forceEndOfUtteranceMessage);
+    }
+    /**
+     * Configure the threshold for how long to wait before ending an utterance. Default is 700ms.
+     * @param threshold - The duration of the end utterance silence threshold in milliseconds.
+     * This value must be an integer between 0 and 20_000.
+     */
+    configureEndUtteranceSilenceThreshold(threshold) {
+        this.send(`{"end_utterance_silence_threshold":${threshold}}`);
+    }
+    send(data) {
+        if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
+            throw new Error("Socket is not open for communication");
+        }
+        this.socket.send(data);
+    }
+    async close(waitForSessionTermination = true) {
+        if (this.socket) {
+            if (this.socket.readyState === this.socket.OPEN) {
+                if (waitForSessionTermination) {
+                    const sessionTerminatedPromise = new Promise((resolve) => {
+                        this.sessionTerminatedResolve = resolve;
+                    });
+                    this.socket.send(terminateSessionMessage);
+                    await sessionTerminatedPromise;
+                }
+                else {
+                    this.socket.send(terminateSessionMessage);
+                }
+            }
+            if (this.socket?.removeAllListeners)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        this.listeners = {};
+        this.socket = undefined;
+    }
+}
+/**
+ * @deprecated Use RealtimeTranscriber instead
+ */
+class RealtimeService extends RealtimeTranscriber {
+}
+
+export { RealtimeService, RealtimeTranscriber };