@livekit/agents 0.3.5 → 0.4.1

package/dist/worker.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Worker_instances, _Worker_opts, _Worker_procPool, _Worker_id, _Worker_closed, _Worker_draining, _Worker_connecting, _Worker_tasks, _Worker_pending, _Worker_close, _Worker_session, _Worker_httpServer, _Worker_logger, _Worker_runWS, _Worker_availability, _Worker_termination;
 import { JobType, ParticipantPermission, ServerMessage, WorkerMessage, WorkerStatus, } from '@livekit/protocol';
 import { AccessToken, RoomServiceClient } from 'livekit-server-sdk';
 import { EventEmitter } from 'node:events';
@@ -90,6 +78,12 @@ const defaultCpuLoad = async () => {
 };
 /** Participant permissions to pass to every agent spun up by this worker. */
 export class WorkerPermissions {
+    canPublish;
+    canSubscribe;
+    canPublishData;
+    canUpdateMetadata;
+    canPublishSources;
+    hidden;
     constructor(canPublish = true, canSubscribe = true, canPublishData = true, canUpdateMetadata = true, canPublishSources = [], hidden = false) {
         this.canPublish = canPublish;
         this.canSubscribe = canSubscribe;
@@ -109,6 +103,24 @@ export class WorkerPermissions {
  * This class is mostly useful in conjunction with {@link cli.runApp}.
  */
 export class WorkerOptions {
+    agent;
+    requestFunc;
+    loadFunc;
+    loadThreshold;
+    numIdleProcesses;
+    shutdownProcessTimeout;
+    initializeProcessTimeout;
+    permissions;
+    agentName;
+    workerType;
+    maxRetry;
+    wsURL;
+    apiKey;
+    apiSecret;
+    host;
+    port;
+    logLevel;
+    production;
     /** @param options */
     constructor({ agent, requestFunc = defaultRequestFunc, loadFunc = defaultCpuLoad, loadThreshold = undefined, numIdleProcesses = undefined, shutdownProcessTimeout = 60 * 1000, initializeProcessTimeout = 10 * 1000, permissions = new WorkerPermissions(), agentName = '', workerType = JobType.JT_ROOM, maxRetry = MAX_RECONNECT_ATTEMPTS, wsURL = 'ws://localhost:7880', apiKey = undefined, apiSecret = undefined, host = 'localhost', port = undefined, logLevel = 'info', production = false, }) {
         this.agent = agent;
@@ -135,11 +147,9 @@ export class WorkerOptions {
     }
 }
 class PendingAssignment {
-    constructor() {
-        this.promise = new Promise((resolve) => {
-            this.resolve = resolve; // this is how JavaScript lets you resolve promises externally
-        });
-    }
+    promise = new Promise((resolve) => {
+        this.resolve = resolve; // this is how JavaScript lets you resolve promises externally
+    });
     resolve(arg) {
         arg; // useless call to counteract TypeScript E6133
     }
@@ -154,22 +164,21 @@ class PendingAssignment {
  * behind a wrapper.
  */
 export class Worker {
+    #opts;
+    #procPool;
+    #id = 'unregistered';
+    #closed = true;
+    #draining = false;
+    #connecting = false;
+    #tasks = [];
+    #pending = {};
+    #close = new Future();
+    event = new EventEmitter();
+    #session = undefined;
+    #httpServer;
+    #logger = log().child({ version });
     /* @throws {@link MissingCredentialsError} if URL, API key or API secret are missing */
     constructor(opts) {
-        _Worker_instances.add(this);
-        _Worker_opts.set(this, void 0);
-        _Worker_procPool.set(this, void 0);
-        _Worker_id.set(this, 'unregistered');
-        _Worker_closed.set(this, true);
-        _Worker_draining.set(this, false);
-        _Worker_connecting.set(this, false);
-        _Worker_tasks.set(this, []);
-        _Worker_pending.set(this, {});
-        _Worker_close.set(this, new Future());
-        this.event = new EventEmitter();
-        _Worker_session.set(this, undefined);
-        _Worker_httpServer.set(this, void 0);
-        _Worker_logger.set(this, log().child({ version }));
         opts.wsURL = opts.wsURL || process.env.LIVEKIT_URL || '';
         opts.apiKey = opts.apiKey || process.env.LIVEKIT_API_KEY || '';
         opts.apiSecret = opts.apiSecret || process.env.LIVEKIT_API_SECRET || '';
@@ -179,72 +188,72 @@ export class Worker {
             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: Set LIVEKIT_API_SECRET, run with --api-secret, or pass apiSecret in WorkerOptions');
-        __classPrivateFieldSet(this, _Worker_procPool, new ProcPool(opts.agent, opts.numIdleProcesses, opts.initializeProcessTimeout, opts.shutdownProcessTimeout), "f");
-        __classPrivateFieldSet(this, _Worker_opts, opts, "f");
-        __classPrivateFieldSet(this, _Worker_httpServer, new HTTPServer(opts.host, opts.port), "f");
+        this.#procPool = new ProcPool(opts.agent, opts.numIdleProcesses, opts.initializeProcessTimeout, opts.shutdownProcessTimeout);
+        this.#opts = opts;
+        this.#httpServer = new HTTPServer(opts.host, opts.port);
     }
     /* @throws {@link WorkerError} if worker failed to connect or already running */
     async run() {
-        if (!__classPrivateFieldGet(this, _Worker_closed, "f")) {
+        if (!this.#closed) {
             throw new WorkerError('worker is already running');
         }
-        __classPrivateFieldGet(this, _Worker_logger, "f").info('starting worker');
-        __classPrivateFieldSet(this, _Worker_closed, false, "f");
-        __classPrivateFieldGet(this, _Worker_procPool, "f").start();
+        this.#logger.info('starting worker');
+        this.#closed = false;
+        this.#procPool.start();
         const workerWS = async () => {
             let retries = 0;
-            __classPrivateFieldSet(this, _Worker_connecting, true, "f");
-            while (!__classPrivateFieldGet(this, _Worker_closed, "f")) {
-                const url = new URL(__classPrivateFieldGet(this, _Worker_opts, "f").wsURL);
+            this.#connecting = true;
+            while (!this.#closed) {
+                const url = new URL(this.#opts.wsURL);
                 url.protocol = url.protocol.replace('http', 'ws');
-                const token = new AccessToken(__classPrivateFieldGet(this, _Worker_opts, "f").apiKey, __classPrivateFieldGet(this, _Worker_opts, "f").apiSecret);
+                const token = new AccessToken(this.#opts.apiKey, this.#opts.apiSecret);
                 token.addGrant({ agent: true });
                 const jwt = await token.toJwt();
-                __classPrivateFieldSet(this, _Worker_session, new WebSocket(url + 'agent', {
+                this.#session = new WebSocket(url + 'agent', {
                     headers: { authorization: 'Bearer ' + jwt },
-                }), "f");
+                });
                 try {
                     await new Promise((resolve, reject) => {
-                        __classPrivateFieldGet(this, _Worker_session, "f").on('open', resolve);
-                        __classPrivateFieldGet(this, _Worker_session, "f").on('error', (error) => reject(error));
-                        __classPrivateFieldGet(this, _Worker_session, "f").on('close', (code) => reject(new Error(`WebSocket returned ${code}`)));
+                        this.#session.on('open', resolve);
+                        this.#session.on('error', (error) => reject(error));
+                        this.#session.on('close', (code) => reject(new Error(`WebSocket returned ${code}`)));
                     });
                     retries = 0;
-                    __classPrivateFieldGet(this, _Worker_logger, "f").debug('connected to LiveKit server');
-                    __classPrivateFieldGet(this, _Worker_instances, "m", _Worker_runWS).call(this, __classPrivateFieldGet(this, _Worker_session, "f"));
+                    this.#logger.debug('connected to LiveKit server');
+                    this.#runWS(this.#session);
                     return;
                 }
                 catch (e) {
-                    if (__classPrivateFieldGet(this, _Worker_closed, "f"))
+                    if (this.#closed)
                         return;
-                    if (retries >= __classPrivateFieldGet(this, _Worker_opts, "f").maxRetry) {
+                    if (retries >= this.#opts.maxRetry) {
                         throw new WorkerError(`failed to connect to LiveKit server after ${retries} attempts: ${e}`);
                     }
                     retries++;
                     const delay = Math.min(retries * 2, 10);
-                    __classPrivateFieldGet(this, _Worker_logger, "f").warn(`failed to connect to LiveKit server, retrying in ${delay} seconds: ${e} (${retries}/${__classPrivateFieldGet(this, _Worker_opts, "f").maxRetry})`);
+                    this.#logger.warn(`failed to connect to LiveKit server, retrying in ${delay} seconds: ${e} (${retries}/${this.#opts.maxRetry})`);
                     await new Promise((resolve) => setTimeout(resolve, delay * 1000));
                 }
             }
         };
-        await Promise.all([workerWS(), __classPrivateFieldGet(this, _Worker_httpServer, "f").run()]);
-        __classPrivateFieldGet(this, _Worker_close, "f").resolve();
+        await Promise.all([workerWS(), this.#httpServer.run()]);
+        this.#close.resolve();
     }
     get id() {
-        return __classPrivateFieldGet(this, _Worker_id, "f");
+        return this.#id;
     }
     get activeJobs() {
-        return __classPrivateFieldGet(this, _Worker_procPool, "f").processes
+        return this.#procPool.processes
             .filter((proc) => proc.runningJob)
             .map((proc) => proc.runningJob);
     }
     /* @throws {@link WorkerError} if worker did not drain in time */
     async drain(timeout) {
-        if (__classPrivateFieldGet(this, _Worker_draining, "f")) {
+        if (this.#draining) {
             return;
         }
-        __classPrivateFieldGet(this, _Worker_logger, "f").info('draining worker');
-        __classPrivateFieldSet(this, _Worker_draining, true, "f");
+        this.#logger.info('draining worker');
+        this.#draining = true;
         this.event.emit('worker_msg', new WorkerMessage({
             message: {
                 case: 'updateWorker',
@@ -254,7 +263,7 @@ export class Worker {
             },
         }));
         const joinJobs = async () => {
-            return Promise.all(__classPrivateFieldGet(this, _Worker_procPool, "f").processes.map((proc) => {
+            return Promise.all(this.#procPool.processes.map((proc) => {
                 if (!proc.runningJob) {
                     proc.close();
                 }
@@ -271,7 +280,7 @@ export class Worker {
         });
     }
     async simulateJob(roomName, participantIdentity) {
-        const client = new RoomServiceClient(__classPrivateFieldGet(this, _Worker_opts, "f").wsURL, __classPrivateFieldGet(this, _Worker_opts, "f").apiKey, __classPrivateFieldGet(this, _Worker_opts, "f").apiSecret);
+        const client = new RoomServiceClient(this.#opts.wsURL, this.#opts.apiKey, this.#opts.apiSecret);
         const room = await client.createRoom({ name: roomName });
         let participant = undefined;
         if (participantIdentity) {
@@ -279,7 +288,7 @@ export class Worker {
                 participant = await client.getParticipant(roomName, participantIdentity);
             }
             catch (e) {
-                __classPrivateFieldGet(this, _Worker_logger, "f").fatal(`participant with identity ${participantIdentity} not found in room ${roomName}`);
+                this.#logger.fatal(`participant with identity ${participantIdentity} not found in room ${roomName}`);
                 throw e;
             }
         }
@@ -294,208 +303,209 @@ export class Worker {
             },
         }));
     }
-    async close() {
-        var _a;
-        if (__classPrivateFieldGet(this, _Worker_closed, "f")) {
-            await __classPrivateFieldGet(this, _Worker_close, "f").await;
-            return;
-        }
-        __classPrivateFieldGet(this, _Worker_logger, "f").info('shutting down worker');
-        __classPrivateFieldSet(this, _Worker_closed, true, "f");
-        await __classPrivateFieldGet(this, _Worker_procPool, "f").close();
-        await __classPrivateFieldGet(this, _Worker_httpServer, "f").close();
-        await Promise.allSettled(__classPrivateFieldGet(this, _Worker_tasks, "f"));
-        (_a = __classPrivateFieldGet(this, _Worker_session, "f")) === null || _a === void 0 ? void 0 : _a.close();
-        await __classPrivateFieldGet(this, _Worker_close, "f").await;
-    }
-}
-_Worker_opts = new WeakMap(), _Worker_procPool = new WeakMap(), _Worker_id = new WeakMap(), _Worker_closed = new WeakMap(), _Worker_draining = new WeakMap(), _Worker_connecting = new WeakMap(), _Worker_tasks = new WeakMap(), _Worker_pending = new WeakMap(), _Worker_close = new WeakMap(), _Worker_session = new WeakMap(), _Worker_httpServer = new WeakMap(), _Worker_logger = new WeakMap(), _Worker_instances = new WeakSet(), _Worker_runWS = function _Worker_runWS(ws) {
-    let closingWS = false;
-    const send = (msg) => {
-        if (closingWS) {
-            this.event.off('worker_msg', send);
-            return;
-        }
-        ws.send(msg.toBinary());
-    };
-    this.event.on('worker_msg', send);
-    ws.addEventListener('close', () => {
-        closingWS = true;
-        __classPrivateFieldGet(this, _Worker_logger, "f").error('worker connection closed unexpectedly');
-        this.close();
-    });
-    ws.addEventListener('message', (event) => {
-        if (event.type !== 'message') {
-            __classPrivateFieldGet(this, _Worker_logger, "f").warn('unexpected message type: ' + event.type);
-            return;
-        }
-        const msg = new ServerMessage();
-        msg.fromBinary(event.data);
-        // register is the only valid first message, and it is only valid as the
-        // first message
-        if (__classPrivateFieldGet(this, _Worker_connecting, "f") && msg.message.case !== 'register') {
-            throw new WorkerError('expected register response as first message');
-        }
-        switch (msg.message.case) {
-            case 'register': {
-                __classPrivateFieldSet(this, _Worker_id, msg.message.value.workerId, "f");
-                __classPrivateFieldGet(this, _Worker_logger, "f")
-                    .child({ id: this.id, server_info: msg.message.value.serverInfo })
-                    .info('registered worker');
-                this.event.emit('worker_registered', msg.message.value.workerId, msg.message.value.serverInfo);
-                __classPrivateFieldSet(this, _Worker_connecting, false, "f");
-                break;
+    #runWS(ws) {
+        let closingWS = false;
+        const send = (msg) => {
+            if (closingWS) {
+                this.event.off('worker_msg', send);
+                return;
             }
-            case 'availability': {
-                if (!msg.message.value.job)
-                    return;
-                const task = __classPrivateFieldGet(this, _Worker_instances, "m", _Worker_availability).call(this, msg.message.value);
-                __classPrivateFieldGet(this, _Worker_tasks, "f").push(task);
-                task.finally(() => __classPrivateFieldGet(this, _Worker_tasks, "f").splice(__classPrivateFieldGet(this, _Worker_tasks, "f").indexOf(task)));
-                break;
+            ws.send(msg.toBinary());
+        };
+        this.event.on('worker_msg', send);
+        ws.addEventListener('close', () => {
+            closingWS = true;
+            this.#logger.error('worker connection closed unexpectedly');
+            this.close();
+        });
+        ws.addEventListener('message', (event) => {
+            if (event.type !== 'message') {
+                this.#logger.warn('unexpected message type: ' + event.type);
+                return;
             }
-            case 'assignment': {
-                if (!msg.message.value.job)
-                    return;
-                const job = msg.message.value.job;
-                if (job.id in __classPrivateFieldGet(this, _Worker_pending, "f")) {
-                    const task = __classPrivateFieldGet(this, _Worker_pending, "f")[job.id];
-                    delete __classPrivateFieldGet(this, _Worker_pending, "f")[job.id];
-                    task.resolve(msg.message.value);
+            const msg = new ServerMessage();
+            msg.fromBinary(event.data);
+            // register is the only valid first message, and it is only valid as the
+            // first message
+            if (this.#connecting && msg.message.case !== 'register') {
+                throw new WorkerError('expected register response as first message');
+            }
+            switch (msg.message.case) {
+                case 'register': {
+                    this.#id = msg.message.value.workerId;
+                    this.#logger
+                        .child({ id: this.id, server_info: msg.message.value.serverInfo })
+                        .info('registered worker');
+                    this.event.emit('worker_registered', msg.message.value.workerId, msg.message.value.serverInfo);
+                    this.#connecting = false;
+                    break;
                 }
-                else {
-                    __classPrivateFieldGet(this, _Worker_logger, "f").child({ job }).warn('received assignment for unknown job ' + job.id);
+                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;
                 }
-                break;
-            }
-            case 'termination': {
-                const task = __classPrivateFieldGet(this, _Worker_instances, "m", _Worker_termination).call(this, msg.message.value);
-                __classPrivateFieldGet(this, _Worker_tasks, "f").push(task);
-                task.finally(() => __classPrivateFieldGet(this, _Worker_tasks, "f").splice(__classPrivateFieldGet(this, _Worker_tasks, "f").indexOf(task)));
-                break;
-            }
-        }
-    });
-    this.event.emit('worker_msg', new WorkerMessage({
-        message: {
-            case: 'register',
-            value: {
-                type: __classPrivateFieldGet(this, _Worker_opts, "f").workerType,
-                agentName: __classPrivateFieldGet(this, _Worker_opts, "f").agentName,
-                allowedPermissions: new ParticipantPermission({
-                    canPublish: __classPrivateFieldGet(this, _Worker_opts, "f").permissions.canPublish,
-                    canSubscribe: __classPrivateFieldGet(this, _Worker_opts, "f").permissions.canSubscribe,
-                    canPublishData: __classPrivateFieldGet(this, _Worker_opts, "f").permissions.canPublishData,
-                    canUpdateMetadata: __classPrivateFieldGet(this, _Worker_opts, "f").permissions.canUpdateMetadata,
-                    hidden: __classPrivateFieldGet(this, _Worker_opts, "f").permissions.hidden,
-                    agent: true,
-                }),
-                version,
-            },
-        },
-    }));
-    let currentStatus = WorkerStatus.WS_AVAILABLE;
-    const loadMonitor = setInterval(() => {
-        if (closingWS)
-            clearInterval(loadMonitor);
-        const oldStatus = currentStatus;
-        __classPrivateFieldGet(this, _Worker_opts, "f").loadFunc().then((currentLoad) => {
-            const isFull = currentLoad >= __classPrivateFieldGet(this, _Worker_opts, "f").loadThreshold;
-            const currentlyAvailable = !isFull;
-            currentStatus = currentlyAvailable ? WorkerStatus.WS_AVAILABLE : WorkerStatus.WS_FULL;
-            if (oldStatus != currentStatus) {
-                const extra = { load: currentLoad, loadThreshold: __classPrivateFieldGet(this, _Worker_opts, "f").loadThreshold };
-                if (isFull) {
-                    __classPrivateFieldGet(this, _Worker_logger, "f").child(extra).info('worker is at full capacity, marking as unavailable');
+                case 'assignment': {
+                    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];
+                        task.resolve(msg.message.value);
+                    }
+                    else {
+                        this.#logger.child({ job }).warn('received assignment for unknown job ' + job.id);
+                    }
+                    break;
                 }
-                else {
-                    __classPrivateFieldGet(this, _Worker_logger, "f").child(extra).info('worker is below capacity, marking as available');
+                case 'termination': {
+                    const task = this.#termination(msg.message.value);
+                    this.#tasks.push(task);
+                    task.finally(() => this.#tasks.splice(this.#tasks.indexOf(task)));
+                    break;
                 }
             }
-            this.event.emit('worker_msg', new WorkerMessage({
-                message: {
-                    case: 'updateWorker',
-                    value: {
-                        load: currentLoad,
-                        status: currentStatus,
-                    },
-                },
-            }));
         });
-    }, UPDATE_LOAD_INTERVAL);
-}, _Worker_availability = async function _Worker_availability(msg) {
-    let answered = false;
-    const onReject = async () => {
-        answered = true;
         this.event.emit('worker_msg', new WorkerMessage({
             message: {
-                case: 'availability',
+                case: 'register',
                 value: {
-                    jobId: msg.job.id,
-                    available: false,
+                    type: this.#opts.workerType,
+                    agentName: this.#opts.agentName,
+                    allowedPermissions: new ParticipantPermission({
+                        canPublish: this.#opts.permissions.canPublish,
+                        canSubscribe: this.#opts.permissions.canSubscribe,
+                        canPublishData: this.#opts.permissions.canPublishData,
+                        canUpdateMetadata: this.#opts.permissions.canUpdateMetadata,
+                        hidden: this.#opts.permissions.hidden,
+                        agent: true,
+                    }),
+                    version,
                 },
             },
         }));
-    };
-    const onAccept = async (args) => {
-        answered = true;
-        this.event.emit('worker_msg', new WorkerMessage({
-            message: {
-                case: 'availability',
-                value: {
-                    jobId: msg.job.id,
-                    available: true,
-                    participantIdentity: args.identity,
-                    participantName: args.name,
-                    participantMetadata: args.metadata,
+        let currentStatus = WorkerStatus.WS_AVAILABLE;
+        const loadMonitor = setInterval(() => {
+            if (closingWS)
+                clearInterval(loadMonitor);
+            const oldStatus = currentStatus;
+            this.#opts.loadFunc().then((currentLoad) => {
+                const isFull = currentLoad >= this.#opts.loadThreshold;
+                const currentlyAvailable = !isFull;
+                currentStatus = currentlyAvailable ? WorkerStatus.WS_AVAILABLE : WorkerStatus.WS_FULL;
+                if (oldStatus != currentStatus) {
+                    const extra = { load: currentLoad, loadThreshold: this.#opts.loadThreshold };
+                    if (isFull) {
+                        this.#logger.child(extra).info('worker is at full capacity, marking as unavailable');
+                    }
+                    else {
+                        this.#logger.child(extra).info('worker is below capacity, marking as available');
+                    }
+                }
+                this.event.emit('worker_msg', new WorkerMessage({
+                    message: {
+                        case: 'updateWorker',
+                        value: {
+                            load: currentLoad,
+                            status: currentStatus,
+                        },
+                    },
+                }));
+            });
+        }, UPDATE_LOAD_INTERVAL);
+    }
+    async #availability(msg) {
+        let answered = false;
+        const onReject = async () => {
+            answered = true;
+            this.event.emit('worker_msg', new WorkerMessage({
+                message: {
+                    case: 'availability',
+                    value: {
+                        jobId: msg.job.id,
+                        available: false,
+                    },
                 },
-            },
-        }));
-        __classPrivateFieldGet(this, _Worker_pending, "f")[req.id] = new PendingAssignment();
-        const timer = setTimeout(() => {
-            __classPrivateFieldGet(this, _Worker_logger, "f").child({ req }).warn(`assignment for job ${req.id} timed out`);
+            }));
+        };
+        const onAccept = async (args) => {
+            answered = true;
+            this.event.emit('worker_msg', new WorkerMessage({
+                message: {
+                    case: 'availability',
+                    value: {
+                        jobId: msg.job.id,
+                        available: true,
+                        participantIdentity: args.identity,
+                        participantName: args.name,
+                        participantMetadata: args.metadata,
+                    },
+                },
+            }));
+            this.#pending[req.id] = new PendingAssignment();
+            const timer = setTimeout(() => {
+                this.#logger.child({ req }).warn(`assignment for job ${req.id} timed out`);
+                return;
+            }, ASSIGNMENT_TIMEOUT);
+            const asgn = await this.#pending[req.id].promise.then(async (asgn) => {
+                clearTimeout(timer);
+                return asgn;
+            });
+            await this.#procPool.launchJob({
+                acceptArguments: args,
+                job: msg.job,
+                url: asgn.url || this.#opts.wsURL,
+                token: asgn.token,
+            });
+        };
+        const req = new JobRequest(msg.job, onReject, onAccept);
+        this.#logger
+            .child({ job: msg.job, resuming: msg.resuming, agentName: this.#opts.agentName })
+            .info('received job request');
+        const jobRequestTask = async () => {
+            try {
+                await this.#opts.requestFunc(req);
+            }
+            catch (e) {
+                this.#logger
+                    .child({ job: msg.job, resuming: msg.resuming, agentName: this.#opts.agentName })
+                    .info('jobRequestFunc failed');
+                await onReject();
+            }
+            if (!answered) {
+                this.#logger
+                    .child({ job: msg.job, resuming: msg.resuming, agentName: this.#opts.agentName })
+                    .info('no answer was given inside the jobRequestFunc, automatically rejecting the job');
+            }
+        };
+        const task = jobRequestTask();
+        this.#tasks.push(task);
+        task.finally(() => this.#tasks.splice(this.#tasks.indexOf(task)));
+    }
+    async #termination(msg) {
+        const proc = this.#procPool.getByJobId(msg.jobId);
+        if (proc === null) {
+            // safe to ignore
             return;
-        }, ASSIGNMENT_TIMEOUT);
-        const asgn = await __classPrivateFieldGet(this, _Worker_pending, "f")[req.id].promise.then(async (asgn) => {
-            clearTimeout(timer);
-            return asgn;
-        });
-        await __classPrivateFieldGet(this, _Worker_procPool, "f").launchJob({
-            acceptArguments: args,
-            job: msg.job,
-            url: asgn.url || __classPrivateFieldGet(this, _Worker_opts, "f").wsURL,
-            token: asgn.token,
-        });
-    };
-    const req = new JobRequest(msg.job, onReject, onAccept);
-    __classPrivateFieldGet(this, _Worker_logger, "f")
-        .child({ job: msg.job, resuming: msg.resuming, agentName: __classPrivateFieldGet(this, _Worker_opts, "f").agentName })
-        .info('received job request');
-    const jobRequestTask = async () => {
-        try {
-            await __classPrivateFieldGet(this, _Worker_opts, "f").requestFunc(req);
         }
-        catch (e) {
-            __classPrivateFieldGet(this, _Worker_logger, "f")
-                .child({ job: msg.job, resuming: msg.resuming, agentName: __classPrivateFieldGet(this, _Worker_opts, "f").agentName })
-                .info('jobRequestFunc failed');
-            await onReject();
-        }
-        if (!answered) {
-            __classPrivateFieldGet(this, _Worker_logger, "f")
-                .child({ job: msg.job, resuming: msg.resuming, agentName: __classPrivateFieldGet(this, _Worker_opts, "f").agentName })
-                .info('no answer was given inside the jobRequestFunc, automatically rejecting the job');
+        await proc.close();
+    }
+    async close() {
+        if (this.#closed) {
+            await this.#close.await;
+            return;
         }
-    };
-    const task = jobRequestTask();
-    __classPrivateFieldGet(this, _Worker_tasks, "f").push(task);
-    task.finally(() => __classPrivateFieldGet(this, _Worker_tasks, "f").splice(__classPrivateFieldGet(this, _Worker_tasks, "f").indexOf(task)));
-}, _Worker_termination = async function _Worker_termination(msg) {
-    const proc = __classPrivateFieldGet(this, _Worker_procPool, "f").getByJobId(msg.jobId);
-    if (proc === null) {
-        // safe to ignore
-        return;
+        this.#logger.info('shutting down worker');
+        this.#closed = true;
+        await this.#procPool.close();
+        await this.#httpServer.close();
+        await Promise.allSettled(this.#tasks);
+        this.#session?.close();
+        await this.#close.await;
     }
-    await proc.close();
-};
+}
 //# sourceMappingURL=worker.js.map