assemblyai 2.0.0-beta → 2.0.1-beta

package/dist/types/realtime/index.d.ts

@@ -1,17 +1,36 @@
-type RealtimeConnectionParams = {
+import { FinalTranscript, PartialTranscript, RealtimeTranscript, RealtimeTranscriptType } from "../asyncapi.generated";
+type CreateRealtimeServiceParams = {
+    realtimeUrl?: string;
     sampleRate?: number;
     wordBoost?: string[];
-};
-type RealtimeListener = "data" | "error" | "open" | "close";
-type RealtimeTranscriptType = "PartialTranscript" | "FinalTranscript";
-type RealtimeTranscript = {
-    text: string;
-    message_type: RealtimeTranscriptType;
+} & ({
+    apiKey?: string;
+} | {
+    token: string;
+});
+type RealtimeServiceParams = {
+    realtimeUrl?: string;
+    sampleRate?: number;
+    wordBoost?: string[];
+} & ({
+    apiKey: string;
+} | {
+    token: string;
+});
+type RealtimeEvents = "open" | "close" | "transcript" | "transcript.partial" | "transcript.final" | "error";
+type SessionBeginsEventData = {
+    sessionId: string;
+    expiresAt: Date;
 };
 type RealtimeListeners = {
-    data?: (transcript: RealtimeTranscript) => void;
-    error?: (error: Error) => void;
-    open?: () => void;
+    open?: (event: SessionBeginsEventData) => void;
     close?: (code: number, reason: string) => void;
+    transcript?: (transcript: RealtimeTranscript) => void;
+    "transcript.partial"?: (transcript: PartialTranscript) => void;
+    "transcript.final"?: (transcript: FinalTranscript) => void;
+    error?: (error: Error) => void;
+};
+type RealtimeTokenParams = {
+    expires_in: number;
 };
-export type { RealtimeConnectionParams, RealtimeListener, RealtimeTranscript, RealtimeTranscriptType, RealtimeListeners, };
+export type { CreateRealtimeServiceParams, RealtimeServiceParams, RealtimeEvents, RealtimeTranscriptType, SessionBeginsEventData, RealtimeListeners, RealtimeTokenParams, };

package/dist/types/services/abstractions.d.ts

@@ -1,16 +1,16 @@
 /**
  * Interface for classes that can create resources.
  * @template T The type of the resource.
- * @template Props The type of the properties required to create the resource.
+ * @template Parameters The type of the parameters required to create the resource.
  */
-interface Createable<T, Props, Settings = Record<string, any>> {
+interface Createable<T, Parameters, Options = Record<string, any>> {
     /**
      * Create a new resource.
-     * @param data The properties of the new resource.
-     * @param settings The settings used for creating the new resource.
+     * @param params The parameters of the new resource.
+     * @param options The options used for creating the new resource.
      * @return A promise that resolves to the newly created resource.
      */
-    create(params: Props, settings?: Settings | null): Promise<T>;
+    create(params: Parameters, options?: Options): Promise<T>;
 }
 /**
  * Interface for classes that can retrieve resources.
@@ -19,11 +19,11 @@ interface Createable<T, Props, Settings = Record<string, any>> {
  */
 interface Retrieveable<T, Id = string> {
     /**
-     * Retrieve a resource.
+     * Get a resource.
      * @param id The identifier of the resource to retrieve.
      * @return A promise that resolves to the retrieved resource.
      */
-    retrieve(id: Id): Promise<T>;
+    get(id: Id): Promise<T>;
 }
 /**
  * Interface for classes that can delete resources.
@@ -49,32 +49,4 @@ interface Listable<T, Page = string> {
      */
     list(page?: Page): Promise<T>;
 }
-/**
- * Interface for classes that can connect to resources.
- * @template T The type of the resource's data.
- */
-interface Connectable<T, Params> {
-    /**
-     * Connect to a resource.
-     * @param event The event to listen for.
-     * @param listener The listener for the event.
-     */
-    on(event: "data", listener: (data: T) => void): void;
-    on(event: "error", listener: (error: Error) => void): void;
-    on(event: "open", listener: () => void): void;
-    on(event: "close", listener: (code: number, reason: string) => void): void;
-    /**
-     * Send data to the resource.
-     * @param data The data to send.
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Connect to the resource.
-     */
-    connect(params: Params): void;
-    /**
-     * Disconnect from the resource.
-     */
-    disconnect(): void;
-}
-export type { Createable, Retrieveable, Deletable, Listable, Connectable };
+export type { Createable, Retrieveable, Deletable, Listable };

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

@@ -1,9 +1,6 @@
 type BaseServiceParams = {
-    token: string;
+    apiKey: string;
     baseUrl?: string;
 };
-type Upload = {
-    upload_url: string;
-};
 export type * from "./abstractions";
-export type { BaseServiceParams, Upload };
+export type { BaseServiceParams };

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

@@ -0,0 +1,5 @@
+export type CreateTranscriptOptions = {
+    poll?: boolean;
+    pollingInterval?: number;
+    pollingTimeout?: number;
+};

package/dist/utils/axios.d.ts

@@ -0,0 +1,3 @@
+import { BaseServiceParams } from "../.";
+export declare function createAxiosClient(params: BaseServiceParams): import("axios").AxiosInstance;
+export declare function throwApiError(error: unknown): Promise<never>;

package/dist/utils/errors/realtime.d.ts

@@ -1,8 +1,7 @@
 declare enum RealtimeErrorType {
     BadSampleRate = 4000,
     AuthFailed = 4001,
-    InsufficientFunds = 4002,
-    FreeAccount = 4003,
+    InsufficientFundsOrFreeAccount = 4002,
     NonexistentSessionId = 4004,
     SessionExpired = 4008,
     ClosedSession = 4010,
@@ -19,8 +18,6 @@ declare enum RealtimeErrorType {
 }
 declare const RealtimeErrorMessages: Record<RealtimeErrorType, string>;
 declare class RealtimeError extends Error {
-    code: RealtimeErrorType;
-    constructor(code: RealtimeErrorType);
 }
 export { RealtimeErrorType, RealtimeErrorMessages };
 export default RealtimeError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assemblyai",
-  "version": "2.0.0-beta",
+  "version": "2.0.1-beta",
   "description": "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.",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -21,7 +21,8 @@
     "lint": "tslint -p tsconfig.json",
     "test": "pnpm lint && pnpm test:unit",
     "test:unit": "jest --config jest.config.rollup.ts",
-    "prettier": "prettier --write 'src/**/*.ts'"
+    "prettier": "prettier --write 'src/**/*.ts'",
+    "generate-types": "tsx ./scripts/generate-types.ts && pnpm prettier"
   },
   "keywords": [
     "AssemblyAI",
@@ -36,17 +37,20 @@
     "types"
   ],
   "devDependencies": {
-    "@types/jest": "^29.5.2",
+    "@types/jest": "^29.5.5",
     "@types/node": "^20.5.7",
     "@types/ws": "^8.5.5",
+    "dotenv": "^16.3.1",
     "eslint": "^8.43.0",
     "i": "^0.3.7",
     "jest": "^29.5.0",
     "jest-cli": "^29.5.0",
     "jest-junit": "^16.0.0",
     "jest-mock-extended": "^3.0.4",
+    "jest-websocket-mock": "^2.4.1",
     "mock-socket": "^9.2.1",
     "npm": "^9.7.1",
+    "openapi-typescript": "^6.6.1",
     "prettier": "^2.8.8",
     "rimraf": "^5.0.1",
     "rollup": "^3.25.1",
@@ -55,8 +59,7 @@
     "ts-node": "^10.9.1",
     "tslib": "^2.5.3",
     "tslint": "^6.1.3",
-    "typescript": "^5.1.3",
-    "jest-websocket-mock": "^2.4.1"
+    "typescript": "^5.2.2"
   },
   "dependencies": {
     "axios": "^1.4.0",

package/src/index.ts

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

package/src/services/base.ts

@@ -1,5 +1,4 @@
-import axios, { AxiosInstance } from "axios";
-import { BaseServiceParams } from "@/types";
+import { AxiosInstance } from "axios";
 
 /**
  * Base class for services that communicate with the API.
@@ -12,5 +11,4 @@ abstract class BaseService {
   constructor(protected client: AxiosInstance) {}
 }
 
-export type { BaseServiceParams };
 export default BaseService;

package/src/services/files/index.ts

@@ -1,6 +1,6 @@
-import fs from "fs/promises";
+import { readFile } from "fs/promises";
 import BaseService from "@/services/base";
-import { Upload } from "@/types";
+import { UploadedFile } from "@/types";
 
 export default class FileService extends BaseService {
   /**
@@ -9,9 +9,9 @@ export default class FileService extends BaseService {
    * @return A promise that resolves to the uploaded file URL.
    */
   async upload(path: string): Promise<string> {
-    const file = await fs.readFile(path);
+    const file = await readFile(path);
 
-    const { data } = await this.client.post<Upload>("/v2/upload", file, {
+    const { data } = await this.client.post<UploadedFile>("/v2/upload", file, {
       headers: {
         "Content-Type": "application/octet-stream",
       },

package/src/services/index.ts

@@ -1,7 +1,7 @@
-import axios, { isAxiosError } from "axios";
-import { BaseServiceParams } from "./base";
-import LeMURService from "./lemur";
-import RealtimeService from "./realtime";
+import { createAxiosClient } from "@/utils/axios";
+import { BaseServiceParams } from "@/types";
+import LemurService from "./lemur";
+import { RealtimeService, RealtimeServiceFactory } from "./realtime";
 import TranscriptService from "./transcripts";
 import FileService from "./files";
 
@@ -19,48 +19,31 @@ export default class AssemblyAI {
   /**
    * The LeMUR service.
    */
-  public lemur: LeMURService;
+  public lemur: LemurService;
 
   /**
    * The realtime service.
    */
-  public realtime: (params?: { baseUrl: string }) => RealtimeService;
+  public realtime: RealtimeServiceFactory;
 
   /**
    * Create a new AssemblyAI client.
-   * @param params The parameters for the service, including the API token and base URL, if any.
+   * @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 = this.createClient(params);
+    const client = createAxiosClient(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 as string);
-        url.protocol = "wss:";
-        baseUrl = url.toString();
-      }
-      return new RealtimeService({
-        token: params.token,
-        baseUrl,
-      });
-    };
-  }
-
-  private createClient(params: BaseServiceParams) {
-    const client = axios.create({
-      baseURL: params.baseUrl,
-      headers: { Authorization: params.token },
-    });
-
-    client.interceptors.response.use(null, (error) => {
-      if (isAxiosError(error) && error.response?.data?.error) {
-        return Promise.reject(new Error(error.response.data.error));
-      }
-      return Promise.reject(error);
-    });
-    return client;
+    this.lemur = new LemurService(client);
+    this.realtime = new RealtimeServiceFactory(client, params);
   }
 }
+
+export {
+  LemurService,
+  RealtimeServiceFactory,
+  RealtimeService,
+  TranscriptService,
+  FileService,
+};

package/src/services/lemur/index.ts

@@ -1,16 +1,18 @@
 import {
-  LeMURResponse,
-  SummaryParams,
-  QuestionAnswerParams,
-  ActionItemsParams,
-  TaskParams,
-  LeMURQuestionAnswerResponse,
+  LemurSummaryParameters,
+  LemurActionItemsParameters,
+  LemurQuestionAnswerParameters,
+  LemurTaskParameters,
+  LemurSummaryResponse,
+  LemurQuestionAnswerResponse,
+  LemurActionItemsResponse,
+  LemurTaskResponse,
 } from "@/types";
 import BaseService from "@/services/base";
 
-export default class LeMURService extends BaseService {
-  async summary(params: SummaryParams): Promise<LeMURResponse> {
-    const { data } = await this.client.post<LeMURResponse>(
+export default class LemurService extends BaseService {
+  async summary(params: LemurSummaryParameters): Promise<LemurSummaryResponse> {
+    const { data } = await this.client.post<LemurSummaryResponse>(
       "/lemur/v3/generate/summary",
       params
     );
@@ -18,25 +20,27 @@ export default class LeMURService extends BaseService {
   }
 
   async questionAnswer(
-    params: QuestionAnswerParams
-  ): Promise<LeMURQuestionAnswerResponse> {
-    const { data } = await this.client.post<LeMURQuestionAnswerResponse>(
+    params: LemurQuestionAnswerParameters
+  ): Promise<LemurQuestionAnswerResponse> {
+    const { data } = await this.client.post<LemurQuestionAnswerResponse>(
       "/lemur/v3/generate/question-answer",
       params
     );
     return data;
   }
 
-  async actionItems(params: ActionItemsParams): Promise<LeMURResponse> {
-    const { data } = await this.client.post<LeMURResponse>(
+  async actionItems(
+    params: LemurActionItemsParameters
+  ): Promise<LemurActionItemsResponse> {
+    const { data } = await this.client.post<LemurActionItemsResponse>(
       "/lemur/v3/generate/action-items",
       params
     );
     return data;
   }
 
-  async task(params: TaskParams): Promise<LeMURResponse> {
-    const { data } = await this.client.post<LeMURResponse>(
+  async task(params: LemurTaskParameters): Promise<LemurTaskResponse> {
+    const { data } = await this.client.post<LemurTaskResponse>(
       "/lemur/v3/generate/task",
       params
     );

package/src/services/realtime/factory.ts

@@ -0,0 +1,32 @@
+import {
+  BaseServiceParams,
+  RealtimeTokenParams,
+  CreateRealtimeServiceParams,
+  RealtimeServiceParams,
+} from "@/types";
+import { AxiosInstance } from "axios";
+import { RealtimeService } from "./service";
+
+export class RealtimeServiceFactory {
+  constructor(
+    private client: AxiosInstance,
+    private params: BaseServiceParams
+  ) {}
+
+  createService(params?: CreateRealtimeServiceParams): RealtimeService {
+    if (!params) params = { apiKey: this.params.apiKey };
+    else if (!("token" in params) && !params.apiKey) {
+      params.apiKey = this.params.apiKey;
+    }
+
+    return new RealtimeService(params as RealtimeServiceParams);
+  }
+
+  async createTemporaryToken(params: RealtimeTokenParams) {
+    const response = await this.client.post<{ token: string }>(
+      "/v2/realtime/token",
+      params
+    );
+    return response.data.token;
+  }
+}

package/src/services/realtime/index.ts

@@ -1,106 +1,2 @@
-import { BaseServiceParams } from "@/services/base";
-import {
-  Connectable,
-  RealtimeConnectionParams,
-  RealtimeListener,
-  RealtimeListeners,
-  RealtimeTranscript,
-} from "@/types";
-import { RealtimeError, RealtimeErrorType } from "@/utils/errors";
-import WebSocket, { type CloseEvent, type MessageEvent } from "ws";
-
-export default class RealtimeService
-  implements Connectable<RealtimeTranscript, RealtimeConnectionParams>
-{
-  private params: BaseServiceParams;
-  private socket?: WebSocket;
-  private listeners: RealtimeListeners = {};
-
-  constructor(params: BaseServiceParams) {
-    this.params = params;
-  }
-
-  private connectionUrl(
-    connectionParams: Required<RealtimeConnectionParams>
-  ): URL {
-    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: "data", listener: (transcript: RealtimeTranscript) => void): void;
-  on(event: "error", listener: (error: Error) => void): void;
-  on(event: "open", listener: () => void): void;
-  on(event: "close", listener: (code: number, reason: string) => void): void;
-  on(event: RealtimeListener, listener: (...args: any[]) => void) {
-    this.listeners[event] = listener;
-  }
-
-  connect(connectionParams: RealtimeConnectionParams) {
-    if (this.socket) {
-      throw new Error("Already connected");
-    }
-
-    const url = this.connectionUrl({
-      ...connectionParams,
-      sampleRate: connectionParams.sampleRate || 16000,
-      wordBoost: connectionParams.wordBoost || [],
-    });
-
-    this.socket = new WebSocket(url.toString(), {
-      headers: {
-        Authorization: this.params.token,
-      },
-    });
-
-    this.socket.onopen = () => this.listeners.open?.();
-    this.socket.onclose = ({ code, reason }: CloseEvent) =>
-      this.listeners.close?.(code, reason);
-
-    this.socket.onerror = (error) => {
-      const code = error.message as unknown as RealtimeErrorType;
-      const realtimeError = new RealtimeError(code);
-      this.listeners.error?.(realtimeError);
-    };
-
-    this.socket.onmessage = ({ data }: MessageEvent) => {
-      const message = JSON.parse(data.toString()) as RealtimeTranscript;
-      this.listeners.data?.(message);
-    };
-  }
-
-  send(data: ArrayBuffer) {
-    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;
-  }
-}
+export * from "@/services/realtime/factory";
+export * from "@/services/realtime/service";