assemblyai 1.0.1 → 2.0.0-beta

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 AssemblyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,116 +1,125 @@
-## Installing the module:
+# AssemblyAI Node.js SDK
 
-  `npm i assemblyai`
+The AssemblyAI Node.js SDK provides an easy-to-use interface for interacting with the AssemblyAI API,
+which supports async and real-time transcription, as well as the latest LeMUR models.
 
-## Authenticating with the API
+## Installation
 
-### Using Environment Variables
+Use [npm](https://www.npmjs.com/) to install AssemblyAI:
 
-If you have the `ASSEMBLYAI_API_KEY` environment variable set, then the application
-will attempt to read it and use this value to authenticate with the API.
+```bash
+npm install assemblyai
+```
 
-### Setting the value manually
+# Usage
 
-Here is what the code would look like if you were to set the API token manually.
+Import the AssemblyAI package and create an AssemblyAI object with your API token:
 
 ```javascript
-const assemblyai = require('assemblyai')
-assemblyai.setAPIKey("ENTER YOUR KEY HERE")
+import AssemblyAI from 'assemblyai'
+
+const assembly = new AssemblyAI({
+  token: process.env.ASSEMBLYAI_API_KEY,
+})
 ```
 
-## Usage
+You can now use the `assembly` object to interact with the AssemblyAI API.
+
+## Create a Transcript
 
-### Initialization
+When you create a transcript, you can either pass in a URL to an audio file, or upload a file directly.
 
-The initialization of the module of course has to be at the beginning of your project. 
+```javascript
+// Using a remote URL
+const created = await assembly.transcripts.create({
+  audio_url: 'https://storage.googleapis.com/aai-web-samples/espn-bears.m4a',
+})
+```
 
 ```javascript
-const assemblyai = require('assemblyai')
-assemblyai.setAPIKey("ENTER YOUR KEY HERE")
+// Uploading a file
+const created = await assembly.transcripts.create({
+  audio_url: './news.mp4',
+})
 ```
 
-### Upload an audio file for transcription
+## Retrieve a Transcript
+
+This will return the transcript object in its current state. If the transcript is still processing, the `status` field will be `queued` or `processing`. Once the transcript is complete, the `status` field will be `completed`.
+
+```javascript
+const transcript = await assembly.transcripts.retrieve(created.id)
+```
+
+## Poll a Transcript
+
+This will poll the transcript until it is complete. Once the transcript is complete, the `status` field will be `completed`.
 
 ```javascript
-async function upload () {
-  try {
-    const transcript = new assemblyai.Upload('/path/to/audiofile.wav')
-    const response = await transcript.create()
-    const data = response.get()
-    
-    // do something with the JSON response
-    console.log(data);
-    
-  } catch (e) {
-    // Do some error handling here
-  }
-}
+const transcript = await assembly.transcripts.poll({
+  transcript_id: created.id,
+})
 ```
 
-### Transcribe audio from a URL
+## List Transcripts
 
-The only required parameter is the `audio_src_url` parameter. For more information about transcribing audio, please see the full API documentation [here](https://docs.assemblyai.com/api/#posttranscript).
+This will return a list of all transcripts that you have created.
 
 ```javascript
-async function transcribe () {
-  try {
-    const transcript = new assemblyai.Transcript()
-    const response = await transcript.create({
-      audio_src_url: "https://example.com/example.wav",
-      model_id: 123,
-      options: {
-        format_text: true || false
-      }
-    })
-    const { id } = response.get()
-    const data = await transcript.poll(id)
-    
-    // do something with the response data.
-    // `data` is a wrapper of the API's JSON
-    // response. `data.get()` returns the JSON
-    // response of the API
-    var responseJson = data.get();
-    console.log(responseJson);
-    
-  } catch (e) {
-    // Do some error handling here
-  }
-}
+const page = await assembly.transcripts.list()
 ```
 
-### Create a custom model
+## Delete a Transcript
 
-Boost accuracy for keywords/phrases, and add custom terms to the vocabulary with a custom model. For more information, please see the full API documentation [here](https://docs.assemblyai.com/guides/custom_models_101/).
+```javascript
+const res = await assembly.transcripts.delete(transcript.id)
+```
+
+## LeMUR
+
+The SDK supports the latest LeMUR models. You can specify which model you would like to use when creating a transcript.
 
 ```javascript
-async function model() {
-  try {
-    const instance = new assemblyai.Model()
-    const response = await instance.create({
-      phrases: ['foo', 'bar']
-    })
-    const { id } = response.get()
-    const data = await instance.poll(id)
-    
-    // do something with the response data.
-    // `data` is a wrapper of the API's JSON
-    // response. `data.get()` returns the JSON
-    // response of the API
-    var responseJson = data.get();
-    console.log(responseJson);
-    
-  } catch (e) {
-    // Do some error handling
-  }
-}
+// Ask a question about the transcript
+const { response } = await assembly.lemur.create({
+  type: 'question',
+  model: 'basic',
+  transcript_id: '0d295578-8c75-421a-885a-2c487f188927',
+  questions: [
+    {
+      question: 'What are they discussing?',
+      answer_format: 'text',
+    },
+  ],
+})
 ```
-    
-### The Response Object
 
-When using the `Response` object, you will find a couple of methods:
+```javascript
+// Summarize the transcript
+const { response } = await assembly.lemur.create({
+  type: 'summary',
+  model: 'basic',
+  transcript_id: '0d295578-8c75-421a-885a-2c487f188927',
+  context: {
+    speakers: ['Alex', 'Bob'],
+  },
+})
+```
 
-- `get()`
-- `toString()`
-- `stringify()`
+```javascript
+// AI Coach
+const { response } = await assembly.lemur.create({
+  type: 'coach',
+  model: 'basic',
+  transcript_id: '0d295578-8c75-421a-885a-2c487f188927',
+})
+```
+
+# Tests
 
-The method that you will most likely want to use will be `get()` which returns the full JSON object from the API, one level down.
+To run the test suite, first install the dependencies, then run `npm test`:
+
+```bash
+npm install
+npm test
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import AssemblyAI from "./services";
+export default AssemblyAI;

package/dist/index.esm.js

@@ -0,0 +1,378 @@
+import axios, { isAxiosError } from 'axios';
+import WebSocket from 'ws';
+import fs from 'fs/promises';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Base class for services that communicate with the API.
+ */
+class BaseService {
+    /**
+     * Create a new service.
+     * @param params The AxiosInstance to send HTTP requests to the API.
+     */
+    constructor(client) {
+        this.client = client;
+    }
+}
+
+class LeMURService extends BaseService {
+    summary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/summary", params);
+            return data;
+        });
+    }
+    questionAnswer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/question-answer", params);
+            return data;
+        });
+    }
+    actionItems(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/action-items", params);
+            return data;
+        });
+    }
+    task(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/task", params);
+            return data;
+        });
+    }
+}
+
+var RealtimeErrorType;
+(function (RealtimeErrorType) {
+    RealtimeErrorType[RealtimeErrorType["BadSampleRate"] = 4000] = "BadSampleRate";
+    RealtimeErrorType[RealtimeErrorType["AuthFailed"] = 4001] = "AuthFailed";
+    RealtimeErrorType[RealtimeErrorType["InsufficientFunds"] = 4002] = "InsufficientFunds";
+    RealtimeErrorType[RealtimeErrorType["FreeAccount"] = 4003] = "FreeAccount";
+    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.InsufficientFunds]: "Insufficient funds",
+    [RealtimeErrorType.FreeAccount]: "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 {
+    constructor(code) {
+        const message = RealtimeErrorMessages[code];
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+class RealtimeService {
+    constructor(params) {
+        this.listeners = {};
+        this.params = params;
+    }
+    connectionUrl(connectionParams) {
+        if (!this.params.baseUrl) {
+            throw new Error("Missing base URL");
+        }
+        const url = new URL(this.params.baseUrl);
+        if (url.protocol !== "wss:") {
+            throw new Error("Invalid protocol, must be wss");
+        }
+        const searchParams = new URLSearchParams();
+        searchParams.set("sample_rate", connectionParams.sampleRate.toString());
+        searchParams.set("word_boost", connectionParams.wordBoost.join(","));
+        url.search = searchParams.toString();
+        return url;
+    }
+    on(event, listener) {
+        this.listeners[event] = listener;
+    }
+    connect(connectionParams) {
+        if (this.socket) {
+            throw new Error("Already connected");
+        }
+        const url = this.connectionUrl(Object.assign(Object.assign({}, connectionParams), { sampleRate: connectionParams.sampleRate || 16000, wordBoost: connectionParams.wordBoost || [] }));
+        this.socket = new WebSocket(url.toString(), {
+            headers: {
+                Authorization: this.params.token,
+            },
+        });
+        this.socket.onopen = () => { var _a, _b; return (_b = (_a = this.listeners).open) === null || _b === void 0 ? void 0 : _b.call(_a); };
+        this.socket.onclose = ({ code, reason }) => { var _a, _b; return (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason); };
+        this.socket.onerror = (error) => {
+            var _a, _b;
+            const code = error.message;
+            const realtimeError = new RealtimeError(code);
+            (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, realtimeError);
+        };
+        this.socket.onmessage = ({ data }) => {
+            var _a, _b;
+            const message = JSON.parse(data.toString());
+            (_b = (_a = this.listeners).data) === null || _b === void 0 ? void 0 : _b.call(_a, message);
+        };
+    }
+    send(data) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Socket is not open for communication");
+        }
+        const payload = {
+            audio_data: Buffer.from(data).toString("base64"),
+        };
+        this.socket.send(JSON.stringify(payload));
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        this.listeners = {};
+        this.socket = undefined;
+    }
+}
+
+class TranscriptSubtitleService extends BaseService {
+    retrieve({ transcript_id, format, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${transcript_id}/${format}`);
+            return data;
+        });
+    }
+}
+
+class TranscriptRedactionService extends BaseService {
+    retrieve(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${params.transcript_id}/redacted-audio`);
+            return data;
+        });
+    }
+}
+
+class TranscriptService extends BaseService {
+    constructor(client, files) {
+        super(client);
+        this.files = files;
+        this.subtitles = new TranscriptSubtitleService(client);
+        this.redactions = new TranscriptRedactionService(client);
+    }
+    create(params, settings = {
+        pollingInterval: 3000,
+        pollingTimeout: 180000,
+    }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = getPath(params.audio_url);
+            if (path !== null) {
+                const uploadUrl = yield this.files.upload(path);
+                params.audio_url = uploadUrl;
+            }
+            const res = yield this.client.post("/v2/transcript", params);
+            if (settings && settings.pollingInterval) {
+                return yield this.poll(res.data.id, settings);
+            }
+            return res.data;
+        });
+    }
+    poll(transcriptId, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pollingInterval, pollingTimeout, resolver = (t) => t.status === "completed" || t.status === "error", } = settings;
+            const startTime = Date.now();
+            while (true) {
+                const transcript = yield this.retrieve(transcriptId);
+                if (resolver(transcript)) {
+                    return transcript;
+                }
+                else if (Date.now() - startTime < pollingTimeout) {
+                    yield new Promise((resolve) => setTimeout(resolve, pollingInterval));
+                }
+                else {
+                    throw new Error("Polling timeout");
+                }
+            }
+        });
+    }
+    retrieve(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.get(`/v2/transcript/${id}`);
+            return res.data;
+        });
+    }
+    list(nextUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(nextUrl || "/v2/transcript");
+            for (const transcriptListItem of data.transcripts) {
+                transcriptListItem.created = new Date(transcriptListItem.created);
+                transcriptListItem.completed = new Date(transcriptListItem.completed);
+            }
+            return data;
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.delete(`/v2/transcript/${id}`);
+            return res.data;
+        });
+    }
+    /**
+     * Retrieve all segments of a transcript.
+     * @param id The identifier of the transcript.
+     * @param type The type of segment to retrieve.
+     * @return A promise that resolves to the retrieved resource.
+     */
+    segments(id, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${id}/${type}`);
+            return data;
+        });
+    }
+    /**
+     * Retrieve all sentences of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the sentences.
+     */
+    sentences(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.segments(id, "sentences");
+        });
+    }
+    /**
+     * Retrieve all paragraphs of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the paragraphs.
+     */
+    paragraphs(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.segments(id, "paragraphs");
+        });
+    }
+}
+function getPath(path) {
+    let url;
+    try {
+        url = new URL(path);
+        if (url.protocol === "file:")
+            return url.pathname;
+        else
+            return null;
+    }
+    catch (_a) {
+        return path;
+    }
+}
+
+class FileService extends BaseService {
+    /**
+     * Upload a local file to AssemblyAI.
+     * @param path The local file to upload.
+     * @return A promise that resolves to the uploaded file URL.
+     */
+    upload(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield fs.readFile(path);
+            const { data } = yield this.client.post("/v2/upload", file, {
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                },
+            });
+            return data.upload_url;
+        });
+    }
+}
+
+class AssemblyAI {
+    /**
+     * Create a new AssemblyAI client.
+     * @param params The parameters for the service, including the API token and base URL, if any.
+     */
+    constructor(params) {
+        params.baseUrl = params.baseUrl || "https://api.assemblyai.com";
+        const client = this.createClient(params);
+        this.files = new FileService(client);
+        this.transcripts = new TranscriptService(client, this.files);
+        this.lemur = new LeMURService(client);
+        this.realtime = ({ baseUrl } = { baseUrl: "" }) => {
+            if (!baseUrl) {
+                const url = new URL(params.baseUrl);
+                url.protocol = "wss:";
+                baseUrl = url.toString();
+            }
+            return new RealtimeService({
+                token: params.token,
+                baseUrl,
+            });
+        };
+    }
+    createClient(params) {
+        const client = axios.create({
+            baseURL: params.baseUrl,
+            headers: { Authorization: params.token },
+        });
+        client.interceptors.response.use(null, (error) => {
+            var _a, _b;
+            if (isAxiosError(error) && ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error)) {
+                return Promise.reject(new Error(error.response.data.error));
+            }
+            return Promise.reject(error);
+        });
+        return client;
+    }
+}
+
+export { AssemblyAI as default };