@livekit/agents 0.2.0 → 0.3.1

package/src/utils.ts

@@ -116,7 +116,8 @@ export class Mutex {
 
 /** @internal */
 export class Queue<T> {
-  #items: T[] = [];
+  /** @internal */
+  items: T[] = [];
   #limit?: number;
   #events = new EventEmitter();
 
@@ -125,35 +126,173 @@ export class Queue<T> {
   }
 
   async get(): Promise<T> {
-    if (this.#items.length === 0) {
+    if (this.items.length === 0) {
       await once(this.#events, 'put');
     }
-    const item = this.#items.shift()!;
+    const item = this.items.shift()!;
     this.#events.emit('get');
     return item;
   }
 
   async put(item: T) {
-    if (this.#limit && this.#items.length >= this.#limit) {
+    if (this.#limit && this.items.length >= this.#limit) {
       await once(this.#events, 'get');
     }
-    this.#items.push(item);
+    this.items.push(item);
     this.#events.emit('put');
   }
 }
 
 /** @internal */
 export class Future {
-  #await = new Promise<void>((resolve, reject: (_: Error) => void) => {
-    this.resolve = resolve;
-    this.reject = reject;
-  });
+  #await: Promise<void>;
+  #resolvePromise!: () => void;
+  #rejectPromise!: (error: Error) => void;
+  #done: boolean = false;
+
+  constructor() {
+    this.#await = new Promise<void>((resolve, reject) => {
+      this.#resolvePromise = resolve;
+      this.#rejectPromise = reject;
+    });
+  }
 
   get await() {
     return this.#await;
   }
-  resolve() {}
-  reject(_: Error) {
-    _;
+
+  get done() {
+    return this.#done;
+  }
+
+  resolve() {
+    this.#done = true;
+    this.#resolvePromise();
+  }
+
+  reject(error: Error) {
+    this.#done = true;
+    this.#rejectPromise(error);
+  }
+}
+
+/** @internal */
+export class CancellablePromise<T> {
+  #promise: Promise<T>;
+  #cancelFn: () => void;
+  #isCancelled: boolean = false;
+  #error: Error | null = null;
+
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => void,
+      onCancel: (cancelFn: () => void) => void,
+    ) => void,
+  ) {
+    let cancel: () => void;
+
+    this.#promise = new Promise<T>((resolve, reject) => {
+      executor(
+        resolve,
+        (reason) => {
+          this.#error = reason instanceof Error ? reason : new Error(String(reason));
+          reject(reason);
+        },
+        (cancelFn) => {
+          cancel = () => {
+            this.#isCancelled = true;
+            cancelFn();
+          };
+        },
+      );
+    });
+
+    this.#cancelFn = cancel!;
+  }
+
+  get isCancelled(): boolean {
+    return this.#isCancelled;
+  }
+
+  get error(): Error | null {
+    return this.#error;
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | Promise<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(onfulfilled, onrejected);
+  }
+
+  catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | Promise<TResult>) | null,
+  ): Promise<T | TResult> {
+    return this.#promise.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null): Promise<T> {
+    return this.#promise.finally(onfinally);
+  }
+
+  cancel(): void {
+    this.#cancelFn();
+  }
+
+  static from<T>(promise: Promise<T>): CancellablePromise<T> {
+    return new CancellablePromise<T>((resolve, reject) => {
+      promise.then(resolve).catch(reject);
+    });
+  }
+}
+
+/** @internal */
+export async function gracefullyCancel<T>(promise: CancellablePromise<T>): Promise<void> {
+  if (!promise.isCancelled) {
+    promise.cancel();
+  }
+  try {
+    await promise;
+  } catch (error) {
+    // Ignore the error, as it's expected due to cancellation
+  }
+}
+
+/** @internal */
+export class AsyncIterableQueue<T> implements AsyncIterable<T> {
+  private queue: Queue<T | typeof AsyncIterableQueue.QUEUE_END_MARKER>;
+  private closed = false;
+  private static readonly QUEUE_END_MARKER = Symbol('QUEUE_END_MARKER');
+
+  constructor() {
+    this.queue = new Queue<T | typeof AsyncIterableQueue.QUEUE_END_MARKER>();
+  }
+
+  put(item: T): void {
+    if (this.closed) {
+      throw new Error('Queue is closed');
+    }
+    this.queue.put(item);
+  }
+
+  close(): void {
+    this.closed = true;
+    this.queue.put(AsyncIterableQueue.QUEUE_END_MARKER);
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: async (): Promise<IteratorResult<T>> => {
+        if (this.closed && this.queue.items.length === 0) {
+          return { value: undefined, done: true };
+        }
+        const item = await this.queue.get();
+        if (item === AsyncIterableQueue.QUEUE_END_MARKER && this.closed) {
+          return { value: undefined, done: true };
+        }
+        return { value: item as T, done: false };
+      },
+    };
   }
 }

package/src/worker.ts

@@ -31,6 +31,32 @@ const MAX_RECONNECT_ATTEMPTS = 10;
 const ASSIGNMENT_TIMEOUT = 7.5 * 1000;
 const UPDATE_LOAD_INTERVAL = 2.5 * 1000;
 
+class Default {
+  static loadThreshold(production: boolean): number {
+    if (production) {
+      return 0.65;
+    } else {
+      return Infinity;
+    }
+  }
+
+  static numIdleProcesses(production: boolean): number {
+    if (production) {
+      return 3;
+    } else {
+      return 0;
+    }
+  }
+
+  static port(production: boolean): number {
+    if (production) {
+      return 8081;
+    } else {
+      return 0;
+    }
+  }
+}
+
 /** Necessary credentials not provided and not found in an appropriate environmental variable. */
 export class MissingCredentialsError extends Error {
   constructor(msg?: string) {
@@ -132,14 +158,15 @@ export class WorkerOptions {
   host: string;
   port: number;
   logLevel: string;
+  production: boolean;
 
   /** @param options */
   constructor({
     agent,
     requestFunc = defaultRequestFunc,
     loadFunc = defaultCpuLoad,
-    loadThreshold = 0.65,
-    numIdleProcesses = 3,
+    loadThreshold = undefined,
+    numIdleProcesses = undefined,
     shutdownProcessTimeout = 60 * 1000,
     initializeProcessTimeout = 10 * 1000,
     permissions = new WorkerPermissions(),
@@ -150,8 +177,9 @@ export class WorkerOptions {
     apiKey = undefined,
     apiSecret = undefined,
     host = 'localhost',
-    port = 8081,
+    port = undefined,
     logLevel = 'info',
+    production = false,
   }: {
     /**
      * Path to a file that has {@link Agent} as a default export, dynamically imported later for
@@ -176,12 +204,16 @@ export class WorkerOptions {
     host?: string;
     port?: number;
     logLevel?: string;
+    production?: boolean;
   }) {
     this.agent = agent;
+    if (!this.agent) {
+      throw new Error('No Agent file was passed to the worker');
+    }
     this.requestFunc = requestFunc;
     this.loadFunc = loadFunc;
-    this.loadThreshold = loadThreshold;
-    this.numIdleProcesses = numIdleProcesses;
+    this.loadThreshold = loadThreshold || Default.loadThreshold(production);
+    this.numIdleProcesses = numIdleProcesses || Default.numIdleProcesses(production);
     this.shutdownProcessTimeout = shutdownProcessTimeout;
     this.initializeProcessTimeout = initializeProcessTimeout;
     this.permissions = permissions;
@@ -192,8 +224,9 @@ export class WorkerOptions {
     this.apiKey = apiKey;
     this.apiSecret = apiSecret;
     this.host = host;
-    this.port = port;
+    this.port = port || Default.port(production);
     this.logLevel = logLevel;
+    this.production = production;
   }
 }
 
@@ -239,12 +272,16 @@ export class Worker {
     opts.apiSecret = opts.apiSecret || process.env.LIVEKIT_API_SECRET || '';
 
     if (opts.wsURL === '')
-      throw new MissingCredentialsError('--url is required, or set LIVEKIT_URL env var');
+      throw new MissingCredentialsError(
+        'URL is required: Set LIVEKIT_URL, run with --url, or pass wsURL in WorkerOptions',
+      );
     if (opts.apiKey === '')
-      throw new MissingCredentialsError('--api-key is required, or set LIVEKIT_API_KEY env var');
+      throw new MissingCredentialsError(
+        'API Key is required: Set LIVEKIT_API_KEY, run with --api-key, or pass apiKey in WorkerOptions',
+      );
     if (opts.apiSecret === '')
       throw new MissingCredentialsError(
-        '--api-secret is required, or set LIVEKIT_API_SECRET env var',
+        'API Secret is required: Set LIVEKIT_API_SECRET, run with --api-secret, or pass apiSecret in WorkerOptions',
       );
 
     this.#procPool = new ProcPool(
@@ -286,7 +323,7 @@ export class Worker {
           await new Promise((resolve, reject) => {
             this.#session!.on('open', resolve);
             this.#session!.on('error', (error) => reject(error));
-            this.#session!.on('close', (code) => reject(`WebSocket returned ${code}`));
+            this.#session!.on('close', (code) => reject(new Error(`WebSocket returned ${code}`)));
           });
 
           retries = 0;
@@ -373,10 +410,17 @@ export class Worker {
     const room = await client.createRoom({ name: roomName });
     let participant: ParticipantInfo | undefined = undefined;
     if (participantIdentity) {
-      participant = await client.getParticipant(roomName, participantIdentity);
+      try {
+        participant = await client.getParticipant(roomName, participantIdentity);
+      } catch (e) {
+        this.#logger.fatal(
+          `participant with identity ${participantIdentity} not found in room ${roomName}`,
+        );
+        throw e;
+      }
     }
 
-    this.event!.emit(
+    this.event.emit(
       'worker_msg',
       new WorkerMessage({
         message: {
@@ -433,19 +477,21 @@ export class Worker {
           this.event.emit(
             'worker_registered',
             msg.message.value.workerId,
-            msg.message.value.serverInfo!,
+            msg.message.value.serverInfo,
           );
           this.#connecting = false;
           break;
         }
         case 'availability': {
+          if (!msg.message.value.job) return;
           const task = this.#availability(msg.message.value);
           this.#tasks.push(task);
           task.finally(() => this.#tasks.splice(this.#tasks.indexOf(task)));
           break;
         }
         case 'assignment': {
-          const job = msg.message.value.job!;
+          if (!msg.message.value.job) return;
+          const job = msg.message.value.job;
           if (job.id in this.#pending) {
             const task = this.#pending[job.id];
             delete this.#pending[job.id];

package/tsconfig.json

@@ -5,7 +5,7 @@
     // match output dir to input dir. e.g. dist/index instead of dist/src/index
     "rootDir": "./src",
     "declarationDir": "./dist",
-    "outDir": "./dist"
+    "outDir": "./dist",
   },
   "typedocOptions": {
     "name": "agents",