assemblyai 1.0.1 → 2.0.1-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,225 @@
-## Installing the module:
+<img src="https://github.com/AssemblyAI/assemblyai-typescript-sdk/blob/master/assemblyai.png?raw=true" width="500"/>
 
-  `npm i assemblyai`
+---
 
-## Authenticating with the API
+# AssemblyAI Node.js SDK
 
-### Using Environment Variables
+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.
 
-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.
+## Installation
 
-### Setting the value manually
+You can install the AssemblyAI SDK by running:
 
-Here is what the code would look like if you were to set the API token manually.
+```bash
+npm install assemblyai
+```
+
+```bash
+yarn add assemblyai
+```
+
+```bash
+pnpm add assemblyai
+```
+
+```bash
+bun add assemblyai
+```
+
+# Usage
+
+Import the AssemblyAI package and create an AssemblyAI object with your API key:
 
 ```javascript
-const assemblyai = require('assemblyai')
-assemblyai.setAPIKey("ENTER YOUR KEY HERE")
+import AssemblyAI from "assemblyai";
+
+const client = new AssemblyAI({
+  apiKey: process.env.ASSEMBLYAI_API_KEY,
+})
 ```
 
-## Usage
+You can now use the `client` object to interact with the AssemblyAI API.
 
-### Initialization
+## Create a transcript
 
-The initialization of the module of course has to be at the beginning of your project. 
+When you create a transcript, you can either pass in a URL to an audio file, or upload a file directly.
 
 ```javascript
-const assemblyai = require('assemblyai')
-assemblyai.setAPIKey("ENTER YOUR KEY HERE")
+// Using a remote URL
+const transcript = await client.transcripts.create({
+  audio_url: 'https://storage.googleapis.com/aai-web-samples/espn-bears.m4a',
+})
 ```
 
-### Upload an audio file for transcription
+```javascript
+// Uploading a file
+const transcript = await client.transcripts.create({
+  audio_url: './news.mp4',
+})
+```
+
+By default, when you create a transcript, it'll be polled until the status is `completed` or `error`.
+You can configure whether to poll, the polling interval, and polling timeout using these options:
 
 ```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 client.transcripts.create({
+  audio_url: 'https://storage.googleapis.com/aai-web-samples/espn-bears.m4a',
+},
+{
+  // Enable or disable polling. Defaults to true.
+  poll: true,
+  // How frequently the transcript is polled in ms. Defaults to 3000.
+  pollingInterval: 1000,
+  // How long to wait in ms until the "Polling timeout" error is thrown. Defaults to 180000.
+  pollingTimeout: 5000,
+})
 ```
 
-### Transcribe audio from a URL
+## Get a transcript
 
-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 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
-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 transcript = await client.transcripts.get(transcript.id)
 ```
 
-### Create a custom model
+## List transcripts
 
-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/).
+This will return a paged list of transcripts that you have 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
+const page = await client.transcripts.list()
+```
+
+You can also paginate over all pages.
+
+```typescript
+let nextPageUrl: string | null = null;
+do {
+  const page = await client.transcripts.list(nextPageUrl)
+  nextPageUrl = page.page_details.next_url
+} while(nextPageUrl !== null)
+```
+
+## Delete a transcript
+
+```javascript
+const res = await client.transcripts.delete(transcript.id)
+```
+
+## Use LeMUR
+
+Call [LeMUR endpoints](https://www.assemblyai.com/docs/API%20reference/lemur) to summarize, ask questions, generate action items, or run a custom task.
+
+Custom Summary:
+```javascript
+const { response } = await client.lemur.summary({
+  transcript_ids: ['0d295578-8c75-421a-885a-2c487f188927'],
+  answer_format: 'one sentence',
+  context: {
+    speakers: ['Alex', 'Bob'],
   }
-}
+})
+```
+
+Question & Answer:
+```javascript
+const { response } = await client.lemur.questionAnswer({
+  transcript_ids: ['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:
+Action Items:
+```javascript
+const { response } = await client.lemur.actionItems({
+  transcript_ids: ['0d295578-8c75-421a-885a-2c487f188927'],
+})
+```
+
+Custom Task:
+```javascript
+const { response } = await client.lemur.task({
+  transcript_ids: ['0d295578-8c75-421a-885a-2c487f188927'],
+  prompt: 'Write a haiku about this conversation.',
+})
+```
+
+## Transcribe in real time
+
+Create the real-time service.
+
+```typescript
+const service = client.realtime.createService();
+```
+
+You can also pass in the following options.
+
+```typescript
+const service = client.realtime.createService({
+  realtimeUrl: 'wss://localhost/override',
+  apiKey: process.env.ASSEMBLYAI_API_KEY // The API key passed to `AssemblyAI` will be used by default,
+  sampleRate: 16_000,
+  wordBoost: ['foo', 'bar']
+});
+```
+
+You can also generate a temporary auth token for real-time.
+
+```typescript
+const token = await client.realtime.createTemporaryToken({expires_in = 60});
+const rt = client.realtime.createService({
+  token: token
+});
+```
 
-- `get()`
-- `toString()`
-- `stringify()`
+> [!WARNING]
+> Storing your API key in client-facing applications exposes your API key.
+> Generate a temporary auth token on the server and pass it to your client.
 
-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.
+You can configure the following events.
+
+```typescript
+rt.on("open", ({ sessionId, expiresAt }) => console.log('Session ID:', sessionId, 'Expires at:', expiresAt));
+rt.on("close", (code: number, reason: string) => console.log('Closed', code, reason));
+rt.on("transcript", (transcript: TranscriptMessage) => console.log('Transcript:', transcript));
+rt.on("transcript.partial", (transcript: PartialTranscriptMessage) => console.log('Partial transcript:', transcript));
+rt.on("transcript.final", (transcript: FinalTranscriptMessage) => console.log('Final transcript:', transcript));
+rt.on("error", (error: Error) => console.error('Error', error));
+```
+
+After configuring your events, connect to the server.
+
+```typescript
+await rt.connect();
+```
+
+Send audio data.
+
+```typescript
+// Pseudo code for getting audio
+getAudio((chunk) => {
+  rt.sendAudio(chunk);
+});
+```
+
+Close the connection when you're finished.
+
+```typescript
+rt.close();
+```
+
+# Tests
+
+To run the test suite, first install the dependencies, then run `pnpm test`:
+
+```bash
+pnpm install
+pnpm test
+```

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import AssemblyAI from "./services";
+export * from "./services";
+export type * from "./types";
+export default AssemblyAI;