assemblyai 3.0.0 → 3.1.0

package/src/services/base.ts

@@ -1,4 +1,5 @@
-import { AxiosInstance } from "axios";
+import { BaseServiceParams } from "..";
+import { Error as JsonError } from "..";
 
 /**
  * Base class for services that communicate with the API.
@@ -6,7 +7,47 @@ import { AxiosInstance } from "axios";
 export abstract class BaseService {
   /**
    * Create a new service.
-   * @param params The AxiosInstance to send HTTP requests to the API.
+   * @param params The parameters to use for the service.
    */
-  constructor(protected client: AxiosInstance) {}
+  constructor(private params: BaseServiceParams) {}
+  protected async fetch(
+    input: string,
+    init?: RequestInit | undefined
+  ): Promise<Response> {
+    init = init ?? {};
+    init.headers = init.headers ?? {};
+    init.headers = {
+      Authorization: this.params.apiKey,
+      "Content-Type": "application/json",
+      ...init.headers,
+    };
+    if (!input.startsWith("http")) input = this.params.baseUrl + input;
+
+    const response = await fetch(input, init);
+
+    if (response.status >= 400) {
+      let json: JsonError | undefined;
+      const text = await response.text();
+      if (text) {
+        try {
+          json = JSON.parse(text);
+        } catch {
+          /* empty */
+        }
+        if (json?.error) throw new Error(json.error);
+        throw new Error(text);
+      }
+      throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+    }
+
+    return response;
+  }
+
+  protected async fetchJson<T>(
+    input: string,
+    init?: RequestInit | undefined
+  ): Promise<T> {
+    const response = await this.fetch(input, init);
+    return response.json() as Promise<T>;
+  }
 }

package/src/services/files/index.ts

@@ -1,8 +1,8 @@
 // import the fs module instead if specific named exports
 // to keep the assemblyai module more compatible. Some fs polyfills don't include `createReadStream`.
 import fs from "fs";
-import { BaseService } from "@/services/base";
-import { UploadedFile, FileUploadParameters, FileUploadData } from "@/types";
+import { BaseService } from "../base";
+import { UploadedFile, FileUploadParameters, FileUploadData } from "../..";
 
 export class FileService extends BaseService {
   /**
@@ -15,16 +15,14 @@ export class FileService extends BaseService {
     if (typeof input === "string") fileData = fs.createReadStream(input);
     else fileData = input;
 
-    const { data } = await this.client.post<UploadedFile>(
-      "/v2/upload",
-      fileData,
-      {
-        headers: {
-          "Content-Type": "application/octet-stream",
-        },
-      }
-    );
-
+    const data = await this.fetchJson<UploadedFile>("/v2/upload", {
+      method: "POST",
+      body: fileData as BodyInit,
+      headers: {
+        "Content-Type": "application/octet-stream",
+      },
+      duplex: "half",
+    } as RequestInit);
     return data.upload_url;
   }
 }

package/src/services/index.ts

@@ -1,10 +1,11 @@
-import { createAxiosClient } from "@/utils/axios";
-import { BaseServiceParams } from "@/types";
+import { BaseServiceParams } from "..";
 import { LemurService } from "./lemur";
 import { RealtimeService, RealtimeServiceFactory } from "./realtime";
 import { TranscriptService } from "./transcripts";
 import { FileService } from "./files";
 
+const defaultBaseUrl = "https://api.assemblyai.com";
+
 class AssemblyAI {
   /**
    * The files service.
@@ -31,12 +32,13 @@ class AssemblyAI {
    * @param params The parameters for the service, including the API key and base URL, if any.
    */
   constructor(params: BaseServiceParams) {
-    params.baseUrl = params.baseUrl || "https://api.assemblyai.com";
-    const client = createAxiosClient(params);
-    this.files = new FileService(client);
-    this.transcripts = new TranscriptService(client, this.files);
-    this.lemur = new LemurService(client);
-    this.realtime = new RealtimeServiceFactory(client, params);
+    params.baseUrl = params.baseUrl || defaultBaseUrl;
+    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);
+    this.realtime = new RealtimeServiceFactory(params);
   }
 }
 

package/src/services/lemur/index.ts

@@ -8,54 +8,55 @@ import {
   LemurActionItemsResponse,
   LemurTaskResponse,
   PurgeLemurRequestDataResponse,
-} from "@/types";
-import { BaseService } from "@/services/base";
+} from "../..";
+import { BaseService } from "../base";
 
 export class LemurService extends BaseService {
-  async summary(params: LemurSummaryParameters): Promise<LemurSummaryResponse> {
-    const { data } = await this.client.post<LemurSummaryResponse>(
-      "/lemur/v3/generate/summary",
-      params
-    );
-    return data;
+  summary(params: LemurSummaryParameters): Promise<LemurSummaryResponse> {
+    return this.fetchJson<LemurSummaryResponse>("/lemur/v3/generate/summary", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
   }
 
-  async questionAnswer(
+  questionAnswer(
     params: LemurQuestionAnswerParameters
   ): Promise<LemurQuestionAnswerResponse> {
-    const { data } = await this.client.post<LemurQuestionAnswerResponse>(
+    return this.fetchJson<LemurQuestionAnswerResponse>(
       "/lemur/v3/generate/question-answer",
-      params
+      {
+        method: "POST",
+        body: JSON.stringify(params),
+      }
     );
-    return data;
   }
 
-  async actionItems(
+  actionItems(
     params: LemurActionItemsParameters
   ): Promise<LemurActionItemsResponse> {
-    const { data } = await this.client.post<LemurActionItemsResponse>(
+    return this.fetchJson<LemurActionItemsResponse>(
       "/lemur/v3/generate/action-items",
-      params
+      {
+        method: "POST",
+        body: JSON.stringify(params),
+      }
     );
-    return data;
   }
 
-  async task(params: LemurTaskParameters): Promise<LemurTaskResponse> {
-    const { data } = await this.client.post<LemurTaskResponse>(
-      "/lemur/v3/generate/task",
-      params
-    );
-    return data;
+  task(params: LemurTaskParameters): Promise<LemurTaskResponse> {
+    return this.fetchJson<LemurTaskResponse>("/lemur/v3/generate/task", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
   }
 
   /**
    * Delete the data for a previously submitted LeMUR request.
    * @param id ID of the LeMUR request
    */
-  async purgeRequestData(id: string): Promise<PurgeLemurRequestDataResponse> {
-    const { data } = await this.client.delete<PurgeLemurRequestDataResponse>(
-      `/lemur/v3/${id}`
-    );
-    return data;
+  purgeRequestData(id: string): Promise<PurgeLemurRequestDataResponse> {
+    return this.fetchJson<PurgeLemurRequestDataResponse>(`/lemur/v3/${id}`, {
+      method: "DELETE",
+    });
   }
 }

package/src/services/realtime/factory.ts

@@ -3,30 +3,35 @@ import {
   RealtimeTokenParams,
   CreateRealtimeServiceParams,
   RealtimeServiceParams,
-} from "@/types";
-import { AxiosInstance } from "axios";
+  RealtimeTemporaryTokenResponse,
+} from "../..";
 import { RealtimeService } from "./service";
+import { BaseService } from "../base";
 
-export class RealtimeServiceFactory {
-  constructor(
-    private client: AxiosInstance,
-    private params: BaseServiceParams
-  ) {}
+export class RealtimeServiceFactory extends BaseService {
+  private rtFactoryParams: BaseServiceParams;
+  constructor(params: BaseServiceParams) {
+    super(params);
+    this.rtFactoryParams = params;
+  }
 
   createService(params?: CreateRealtimeServiceParams): RealtimeService {
-    if (!params) params = { apiKey: this.params.apiKey };
+    if (!params) params = { apiKey: this.rtFactoryParams.apiKey };
     else if (!("token" in params) && !params.apiKey) {
-      params.apiKey = this.params.apiKey;
+      params.apiKey = this.rtFactoryParams.apiKey;
     }
 
     return new RealtimeService(params as RealtimeServiceParams);
   }
 
   async createTemporaryToken(params: RealtimeTokenParams) {
-    const response = await this.client.post<{ token: string }>(
+    const data = await this.fetchJson<RealtimeTemporaryTokenResponse>(
       "/v2/realtime/token",
-      params
+      {
+        method: "POST",
+        body: JSON.stringify(params),
+      }
     );
-    return response.data.token;
+    return data.token;
   }
 }

package/src/services/realtime/index.ts

@@ -1,2 +1,2 @@
-export * from "@/services/realtime/factory";
-export * from "@/services/realtime/service";
+export * from "./factory";
+export * from "./service";

package/src/services/realtime/service.ts

@@ -8,13 +8,13 @@ import {
   PartialTranscript,
   FinalTranscript,
   SessionBeginsEventData,
-} from "@/types";
+} from "../..";
 import {
   RealtimeError,
   RealtimeErrorMessages,
   RealtimeErrorType,
-} from "@/utils/errors";
-import { Writable } from "stream";
+} from "../../utils/errors";
+import Stream from "stream";
 
 const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
 
@@ -32,7 +32,6 @@ export class RealtimeService {
     this.realtimeUrl = params.realtimeUrl ?? defaultRealtimeUrl;
     this.sampleRate = params.sampleRate ?? 16_000;
     this.wordBoost = params.wordBoost;
-    this.realtimeUrl = params.realtimeUrl ?? defaultRealtimeUrl;
     if ("apiKey" in params) this.apiKey = params.apiKey;
     if ("token" in params) this.token = params.token;
 
@@ -162,8 +161,8 @@ export class RealtimeService {
     this.socket.send(JSON.stringify(payload));
   }
 
-  stream(): Writable {
-    const stream = new Writable({
+  stream(): NodeJS.WritableStream {
+    const stream = new Stream.Writable({
       write: (chunk: Buffer, encoding, next) => {
         this.sendAudio(chunk);
         next();

package/src/services/transcripts/index.ts

@@ -1,4 +1,4 @@
-import { BaseService } from "@/services/base";
+import { BaseService } from "../base";
 import {
   ParagraphsResponse,
   SentencesResponse,
@@ -14,8 +14,9 @@ import {
   RedactedAudioResponse,
   TranscriptListParameters,
   WordSearchResponse,
-} from "@/types";
-import { AxiosInstance } from "axios";
+  BaseServiceParams,
+  PollingOptions,
+} from "../..";
 import { FileService } from "../files";
 
 export class TranscriptService
@@ -26,8 +27,8 @@ export class TranscriptService
     Deletable<Transcript>,
     Listable<TranscriptList>
 {
-  constructor(client: AxiosInstance, private files: FileService) {
-    super(client);
+  constructor(params: BaseServiceParams, private files: FileService) {
+    super(params);
   }
 
   /**
@@ -46,19 +47,24 @@ export class TranscriptService
       params.audio_url = uploadUrl;
     }
 
-    const res = await this.client.post<Transcript>("/v2/transcript", params);
+    const data = await this.fetchJson<Transcript>("/v2/transcript", {
+      method: "POST",
+      body: JSON.stringify(params),
+    });
 
     if (options?.poll ?? true) {
-      return await this.poll(res.data.id, options);
+      return await this.waitUntilReady(data.id, options);
     }
 
-    return res.data;
+    return data;
   }
 
-  private async poll(
+  async waitUntilReady(
     transcriptId: string,
-    options?: CreateTranscriptOptions
+    options?: PollingOptions
   ): Promise<Transcript> {
+    const pollingInterval = options?.pollingInterval ?? 3_000;
+    const pollingTimeout = options?.pollingTimeout ?? -1;
     const startTime = Date.now();
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -66,14 +72,12 @@ export class TranscriptService
       if (transcript.status === "completed" || transcript.status === "error") {
         return transcript;
       } else if (
-        Date.now() - startTime <
-        (options?.pollingTimeout ?? 180_000)
+        pollingTimeout > 0 &&
+        Date.now() - startTime > pollingTimeout
       ) {
-        await new Promise((resolve) =>
-          setTimeout(resolve, options?.pollingInterval ?? 3_000)
-        );
-      } else {
         throw new Error("Polling timeout");
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, pollingInterval));
       }
     }
   }
@@ -83,9 +87,8 @@ export class TranscriptService
    * @param id The identifier of the transcript.
    * @returns A promise that resolves to the transcript.
    */
-  async get(id: string): Promise<Transcript> {
-    const res = await this.client.get<Transcript>(`/v2/transcript/${id}`);
-    return res.data;
+  get(id: string): Promise<Transcript> {
+    return this.fetchJson<Transcript>(`/v2/transcript/${id}`);
   }
 
   /**
@@ -96,15 +99,17 @@ export class TranscriptService
     parameters?: TranscriptListParameters | string
   ): Promise<TranscriptList> {
     let url = "/v2/transcript";
-    let query: TranscriptListParameters | undefined;
     if (typeof parameters === "string") {
       url = parameters;
     } else if (parameters) {
-      query = parameters;
+      url = `${url}?${new URLSearchParams(
+        Object.keys(parameters).map((key) => [
+          key,
+          parameters[key as keyof TranscriptListParameters]?.toString() || "",
+        ])
+      )}`;
     }
-    const { data } = await this.client.get<TranscriptList>(url, {
-      params: query,
-    });
+    const data = await this.fetchJson<TranscriptList>(url);
     for (const transcriptListItem of data.transcripts) {
       transcriptListItem.created = new Date(transcriptListItem.created);
       if (transcriptListItem.completed) {
@@ -112,7 +117,7 @@ export class TranscriptService
       }
     }
 
-    return data as unknown as TranscriptList;
+    return data;
   }
 
   /**
@@ -120,28 +125,22 @@ export class TranscriptService
    * @param id The identifier of the transcript.
    * @returns A promise that resolves to the transcript.
    */
-  async delete(id: string): Promise<Transcript> {
-    const res = await this.client.delete<Transcript>(`/v2/transcript/${id}`);
-    return res.data;
+  delete(id: string): Promise<Transcript> {
+    return this.fetchJson(`/v2/transcript/${id}`, { method: "DELETE" });
   }
 
   /**
    * Search through the transcript for a specific set of keywords.
    * You can search for individual words, numbers, or phrases containing up to five words or numbers.
    * @param id The identifier of the transcript.
-   * @param id Keywords to search for.
+   * @param words Keywords to search for.
    * @return A promise that resolves to the sentences.
    */
-  async wordSearch(id: string, words: string[]): Promise<WordSearchResponse> {
-    const { data } = await this.client.get<WordSearchResponse>(
-      `/v2/transcript/${id}/word-search`,
-      {
-        params: {
-          words: JSON.stringify(words),
-        },
-      }
+  wordSearch(id: string, words: string[]): Promise<WordSearchResponse> {
+    const params = new URLSearchParams({ words: words.join(",") });
+    return this.fetchJson<WordSearchResponse>(
+      `/v2/transcript/${id}/word-search?${params.toString()}`
     );
-    return data;
   }
 
   /**
@@ -149,11 +148,8 @@ export class TranscriptService
    * @param id The identifier of the transcript.
    * @return A promise that resolves to the sentences.
    */
-  async sentences(id: string): Promise<SentencesResponse> {
-    const { data } = await this.client.get<SentencesResponse>(
-      `/v2/transcript/${id}/sentences`
-    );
-    return data;
+  sentences(id: string): Promise<SentencesResponse> {
+    return this.fetchJson<SentencesResponse>(`/v2/transcript/${id}/sentences`);
   }
 
   /**
@@ -161,25 +157,32 @@ export class TranscriptService
    * @param id The identifier of the transcript.
    * @return A promise that resolves to the paragraphs.
    */
-  async paragraphs(id: string): Promise<ParagraphsResponse> {
-    const { data } = await this.client.get<ParagraphsResponse>(
+  paragraphs(id: string): Promise<ParagraphsResponse> {
+    return this.fetchJson<ParagraphsResponse>(
       `/v2/transcript/${id}/paragraphs`
     );
-    return data;
   }
 
   /**
    * Retrieve subtitles of a transcript.
    * @param id The identifier of the transcript.
    * @param format The format of the subtitles.
+   * @param chars_per_caption The maximum number of characters per caption.
    * @return A promise that resolves to the subtitles text.
    */
-  async subtitles(id: string, format: SubtitleFormat = "srt"): Promise<string> {
-    const { data } = await this.client.get<string>(
-      `/v2/transcript/${id}/${format}`
-    );
-
-    return data;
+  async subtitles(
+    id: string,
+    format: SubtitleFormat = "srt",
+    chars_per_caption?: number
+  ): Promise<string> {
+    let url = `/v2/transcript/${id}/${format}`;
+    if (chars_per_caption) {
+      const params = new URLSearchParams();
+      params.set("chars_per_caption", chars_per_caption.toString());
+      url += `?${params.toString()}`;
+    }
+    const response = await this.fetch(url);
+    return await response.text();
   }
 
   /**
@@ -187,11 +190,10 @@ export class TranscriptService
    * @param id The identifier of the transcript.
    * @return A promise that resolves to the subtitles text.
    */
-  async redactions(id: string): Promise<RedactedAudioResponse> {
-    const { data } = await this.client.get<RedactedAudioResponse>(
+  redactions(id: string): Promise<RedactedAudioResponse> {
+    return this.fetchJson<RedactedAudioResponse>(
       `/v2/transcript/${id}/redacted-audio`
     );
-    return data;
   }
 }
 

package/src/types/asyncapi.generated.ts

@@ -14,19 +14,19 @@ type OneOf<T extends any[]> = T extends [infer Only]
   : never;
 
 export type AudioData = {
-  /** @description Raw audio data, base64 encoded. This can be the raw data recorded directly from a microphone or read from an audio file. */
+  /** @description Base64 encoded raw audio data */
   audio_data: string;
 };
 
 export type FinalTranscript = RealtimeBaseTranscript & {
   /**
-   * @description Describes the type of message.
+   * @description Describes the type of message
    * @constant
    */
   message_type: "FinalTranscript";
-  /** @description Whether the text has been punctuated and cased. */
+  /** @description Whether the text is punctuated and cased */
   punctuated: boolean;
-  /** @description Whether the text has been formatted (e.g. Dollar -> $) */
+  /** @description Whether the text is formatted, for example Dollar -> $ */
   text_formatted: boolean;
 };
 
@@ -39,32 +39,35 @@ export type MessageType =
 
 export type PartialTranscript = RealtimeBaseTranscript & {
   /**
-   * @description Describes the type of message.
+   * @description Describes the type of message
    * @constant
    */
   message_type: "PartialTranscript";
 };
 
 export type RealtimeBaseMessage = {
-  /** @description Describes the type of the message. */
+  /** @description Describes the type of the message */
   message_type: MessageType;
 };
 
 export type RealtimeBaseTranscript = {
-  /** @description End time of audio sample relative to session start, in milliseconds. */
+  /** @description End time of audio sample relative to session start, in milliseconds */
   audio_end: number;
-  /** @description Start time of audio sample relative to session start, in milliseconds. */
+  /** @description Start time of audio sample relative to session start, in milliseconds */
   audio_start: number;
   /**
    * Format: double
-   * @description The confidence score of the entire transcription, between 0 and 1.
+   * @description The confidence score of the entire transcription, between 0 and 1
    */
   confidence: number;
-  /** @description The timestamp for the partial transcript. */
+  /** @description The timestamp for the partial transcript */
   created: Date;
-  /** @description The partial transcript for your audio. */
+  /** @description The partial transcript for your audio */
   text: string;
-  /** @description An array of objects, with the information for each word in the transcription text. Includes the start/end time (in milliseconds) of the word, the confidence score of the word, and the text (i.e. the word itself). */
+  /**
+   * @description An array of objects, with the information for each word in the transcription text.
+   * Includes the start and end time of the word in milliseconds, the confidence score of the word, and the text, which is the word itself.
+   */
   words: Word[];
 };
 
@@ -85,27 +88,27 @@ export type RealtimeTranscript = PartialTranscript | FinalTranscript;
 export type RealtimeTranscriptType = "PartialTranscript" | "FinalTranscript";
 
 export type SessionBegins = RealtimeBaseMessage & {
-  /** @description Timestamp when this session will expire. */
+  /** @description Timestamp when this session will expire */
   expires_at: Date;
   /**
-   * @description Describes the type of the message.
+   * @description Describes the type of the message
    * @constant
    */
   message_type: "SessionBegins";
-  /** @description Unique identifier for the established session. */
+  /** @description Unique identifier for the established session */
   session_id: string;
 };
 
 export type SessionTerminated = RealtimeBaseMessage & {
   /**
-   * @description Describes the type of the message.
+   * @description Describes the type of the message
    * @constant
    */
   message_type: "SessionTerminated";
 };
 
 export type TerminateSession = RealtimeBaseMessage & {
-  /** @description A boolean value to communicate that you wish to end your real-time session forever. */
+  /** @description Set to true to end your real-time session forever */
   terminate_session: boolean;
 };
 

package/src/types/files/index.ts

@@ -2,7 +2,8 @@ type FileUploadParameters = string | FileUploadData;
 type FileUploadData =
   | NodeJS.ReadableStream
   | ReadableStream
-  | Buffer
+  | Blob
+  | BufferSource
   | ArrayBufferView
   | ArrayBufferLike
   | Uint8Array;

package/src/types/index.ts

@@ -1,6 +1,6 @@
-export type * from "./files";
-export type * from "./transcripts";
-export type * from "./realtime";
-export type * from "./services";
-export type * from "./asyncapi.generated";
-export type * from "./openapi.generated";
+export * from "./files";
+export * from "./transcripts";
+export * from "./realtime";
+export * from "./services";
+export * from "./asyncapi.generated";
+export * from "./openapi.generated";