@livekit/agents 0.1.0 → 0.3.0

package/dist/worker.js

@@ -1,296 +1,497 @@
-// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
-//
-// SPDX-License-Identifier: Apache-2.0
-import { JobType, ParticipantPermission, ServerMessage, WorkerMessage, } from '@livekit/protocol';
+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 { EventEmitter } from 'events';
-import { AccessToken } from 'livekit-server-sdk';
+import { AccessToken, RoomServiceClient } from 'livekit-server-sdk';
 import os from 'os';
 import { WebSocket } from 'ws';
 import { HTTPServer } from './http_server.js';
-import { JobProcess } from './ipc/job_process.js';
-import { JobRequest } from './job_request.js';
+import { ProcPool } from './ipc/proc_pool.js';
+import { JobRequest } from './job.js';
 import { log } from './log.js';
+import { Future } from './utils.js';
 import { version } from './version.js';
 const MAX_RECONNECT_ATTEMPTS = 10;
-const ASSIGNMENT_TIMEOUT = 15 * 1000;
-const LOAD_INTERVAL = 5 * 1000;
-const cpuLoad = () => (os
-    .cpus()
-    .reduce((acc, x) => acc + x.times.idle / Object.values(x.times).reduce((acc, x) => acc + x, 0), 0) /
-    os.cpus().length) *
-    100;
-class WorkerPermissions {
-    canPublish;
-    canSubscribe;
-    canPublishData;
-    canUpdateMetadata;
-    hidden;
-    constructor(canPublish = true, canSubscribe = true, canPublishData = true, canUpdateMetadata = true, hidden = false) {
+const ASSIGNMENT_TIMEOUT = 7.5 * 1000;
+const UPDATE_LOAD_INTERVAL = 2.5 * 1000;
+class Default {
+    static loadThreshold(production) {
+        if (production) {
+            return 0.65;
+        }
+        else {
+            return Infinity;
+        }
+    }
+    static numIdleProcesses(production) {
+        if (production) {
+            return 3;
+        }
+        else {
+            return 0;
+        }
+    }
+    static port(production) {
+        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) {
+        super(msg);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/** Worker did not run as expected. */
+export class WorkerError extends Error {
+    constructor(msg) {
+        super(msg);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/** @internal */
+export const defaultInitializeProcessFunc = (_) => _;
+const defaultRequestFunc = async (ctx) => {
+    await ctx.accept();
+};
+const defaultCpuLoad = async () => {
+    return new Promise((resolve) => {
+        const cpus1 = os.cpus();
+        setTimeout(() => {
+            const cpus2 = os.cpus();
+            let idle = 0;
+            let total = 0;
+            for (let i = 0; i < cpus1.length; i++) {
+                const cpu1 = cpus1[i].times;
+                const cpu2 = cpus2[i].times;
+                idle += cpu2.idle - cpu1.idle;
+                const total1 = Object.values(cpu1).reduce((acc, i) => acc + i, 0);
+                const total2 = Object.values(cpu2).reduce((acc, i) => acc + i, 0);
+                total += total2 - total1;
+            }
+            resolve(+(1 - idle / total).toFixed(2));
+        }, UPDATE_LOAD_INTERVAL);
+    });
+};
+/** Participant permissions to pass to every agent spun up by this worker. */
+export class WorkerPermissions {
+    constructor(canPublish = true, canSubscribe = true, canPublishData = true, canUpdateMetadata = true, canPublishSources = [], hidden = false) {
         this.canPublish = canPublish;
         this.canSubscribe = canSubscribe;
         this.canPublishData = canPublishData;
         this.canUpdateMetadata = canUpdateMetadata;
+        this.canPublishSources = canPublishSources;
         this.hidden = hidden;
     }
 }
+/**
+ * Data class describing worker behaviour.
+ *
+ * @remarks
+ * The Agents framework provides sane worker defaults, and works out-of-the-box with no tweaking
+ * necessary. The only mandatory parameter is `agent`, which points to the entry function.
+ *
+ * This class is mostly useful in conjunction with {@link cli.runApp}.
+ */
 export class WorkerOptions {
-    requestFunc;
-    cpuLoadFunc;
-    namespace;
-    permissions;
-    workerType;
-    maxRetry;
-    wsURL;
-    apiKey;
-    apiSecret;
-    host;
-    port;
-    constructor({ requestFunc, cpuLoadFunc = cpuLoad, namespace = 'default', permissions = new WorkerPermissions(), workerType = JobType.JT_PUBLISHER, maxRetry = MAX_RECONNECT_ATTEMPTS, wsURL = 'ws://localhost:7880', apiKey = undefined, apiSecret = undefined, host = 'localhost', port = 8081, }) {
+    /** @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;
+        if (!this.agent) {
+            throw new Error('No Agent file was passed to the worker');
+        }
         this.requestFunc = requestFunc;
-        this.cpuLoadFunc = cpuLoadFunc;
-        this.namespace = namespace;
+        this.loadFunc = loadFunc;
+        this.loadThreshold = loadThreshold || Default.loadThreshold(production);
+        this.numIdleProcesses = numIdleProcesses || Default.numIdleProcesses(production);
+        this.shutdownProcessTimeout = shutdownProcessTimeout;
+        this.initializeProcessTimeout = initializeProcessTimeout;
         this.permissions = permissions;
+        this.agentName = agentName;
         this.workerType = workerType;
         this.maxRetry = maxRetry;
         this.wsURL = wsURL;
         this.apiKey = apiKey;
         this.apiSecret = apiSecret;
         this.host = host;
-        this.port = port;
-    }
-}
-class ActiveJob {
-    job;
-    acceptData;
-    constructor(job, acceptData) {
-        this.job = job;
-        this.acceptData = acceptData;
+        this.port = port || Default.port(production);
+        this.logLevel = logLevel;
+        this.production = production;
     }
 }
 class PendingAssignment {
-    promise = new Promise((resolve) => {
-        this.resolve = resolve; // oh, JavaScript.
-    });
+    constructor() {
+        this.promise = new Promise((resolve) => {
+            this.resolve = resolve; // this is how JavaScript lets you resolve promises externally
+        });
+    }
     resolve(arg) {
-        arg;
+        arg; // useless call to counteract TypeScript E6133
     }
 }
+/**
+ * Central orchestrator for all processes and job requests.
+ *
+ * @remarks
+ * For most usecases, Worker should not be initialized or handled directly; you should instead call
+ * for its creation through {@link cli.runApp}. This could, however, be useful in situations where
+ * you don't have access to a command line, such as a headless program, or one that uses Agents
+ * behind a wrapper.
+ */
 export class Worker {
-    opts;
-    #id = 'unregistered';
-    session = undefined;
-    closed = false;
-    httpServer;
-    logger = log.child({ version });
-    event = new EventEmitter();
-    pending = {};
-    processes = {};
+    /* @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 || '';
-        this.opts = opts;
-        this.httpServer = new HTTPServer(opts.host, opts.port);
-    }
-    get id() {
-        return this.#id;
+        if (opts.wsURL === '')
+            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: 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");
     }
+    /* @throws {@link WorkerError} if worker failed to connect or already running */
     async run() {
-        this.logger.info('starting worker');
-        if (this.opts.wsURL === '')
-            throw new Error('--url is required, or set LIVEKIT_URL env var');
-        if (this.opts.apiKey === '')
-            throw new Error('--api-key is required, or set LIVEKIT_API_KEY env var');
-        if (this.opts.apiSecret === '')
-            throw new Error('--api-secret is required, or set LIVEKIT_API_SECRET env var');
+        if (!__classPrivateFieldGet(this, _Worker_closed, "f")) {
+            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();
         const workerWS = async () => {
             let retries = 0;
-            while (!this.closed) {
-                const token = new AccessToken(this.opts.apiKey, this.opts.apiSecret);
+            __classPrivateFieldSet(this, _Worker_connecting, true, "f");
+            while (!__classPrivateFieldGet(this, _Worker_closed, "f")) {
+                const url = new URL(__classPrivateFieldGet(this, _Worker_opts, "f").wsURL);
+                url.protocol = url.protocol.replace('http', 'ws');
+                const token = new AccessToken(__classPrivateFieldGet(this, _Worker_opts, "f").apiKey, __classPrivateFieldGet(this, _Worker_opts, "f").apiSecret);
                 token.addGrant({ agent: true });
                 const jwt = await token.toJwt();
-                const url = new URL(this.opts.wsURL);
-                url.protocol = url.protocol.replace('http', 'ws');
-                this.session = new WebSocket(url + 'agent', {
+                __classPrivateFieldSet(this, _Worker_session, new WebSocket(url + 'agent', {
                     headers: { authorization: 'Bearer ' + jwt },
-                });
+                }), "f");
                 try {
                     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}`));
+                        __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(`WebSocket returned ${code}`));
                     });
-                    this.runWS(this.session);
+                    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"));
                     return;
                 }
                 catch (e) {
-                    if (this.closed)
+                    if (__classPrivateFieldGet(this, _Worker_closed, "f"))
                         return;
-                    if (retries >= this.opts.maxRetry) {
-                        throw new Error(`failed to connect to LiveKit server after ${retries} attempts: ${e}`);
+                    if (retries >= __classPrivateFieldGet(this, _Worker_opts, "f").maxRetry) {
+                        throw new WorkerError(`failed to connect to LiveKit server after ${retries} attempts: ${e}`);
                     }
                     retries++;
                     const delay = Math.min(retries * 2, 10);
-                    this.logger.warn(`failed to connect to LiveKit server, retrying in ${delay} seconds: ${e} (${retries}/${this.opts.maxRetry})`);
+                    __classPrivateFieldGet(this, _Worker_logger, "f").warn(`failed to connect to LiveKit server, retrying in ${delay} seconds: ${e} (${retries}/${__classPrivateFieldGet(this, _Worker_opts, "f").maxRetry})`);
                     await new Promise((resolve) => setTimeout(resolve, delay * 1000));
                 }
             }
         };
-        await Promise.all([workerWS(), this.httpServer.run()]);
+        await Promise.all([workerWS(), __classPrivateFieldGet(this, _Worker_httpServer, "f").run()]);
+        __classPrivateFieldGet(this, _Worker_close, "f").resolve();
     }
-    startProcess(job, acceptData, raw) {
-        const proc = new JobProcess(job, acceptData, raw, this.opts.wsURL);
-        this.processes[job.id] = { proc, activeJob: new ActiveJob(job, acceptData) };
-        proc
-            .run()
-            .catch((e) => {
-            proc.logger.error(`error running job process ${proc.job.id}: ${e}`);
-        })
-            .finally(() => {
-            proc.clear();
-            delete this.processes[job.id];
-        });
+    get id() {
+        return __classPrivateFieldGet(this, _Worker_id, "f");
     }
-    runWS(ws) {
-        let closingWS = false;
-        const send = (msg) => {
-            if (closingWS) {
-                this.event.off('worker_msg', send);
-                return;
-            }
-            ws.send(msg.toBinary());
+    get activeJobs() {
+        return __classPrivateFieldGet(this, _Worker_procPool, "f").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")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _Worker_logger, "f").info('draining worker');
+        __classPrivateFieldSet(this, _Worker_draining, true, "f");
+        this.event.emit('worker_msg', new WorkerMessage({
+            message: {
+                case: 'updateWorker',
+                value: {
+                    status: WorkerStatus.WS_FULL,
+                },
+            },
+        }));
+        const joinJobs = async () => {
+            return Promise.all(__classPrivateFieldGet(this, _Worker_procPool, "f").processes.map((proc) => {
+                if (!proc.runningJob) {
+                    proc.close();
+                }
+                return proc.join();
+            }));
         };
-        this.event.on('worker_msg', send);
-        ws.addEventListener('close', () => {
-            closingWS = true;
-            this.logger.error('worker connection closed unexpectedly');
-            this.close();
+        const timer = setTimeout(() => {
+            throw new WorkerError('timed out draining');
+        }, timeout);
+        if (timeout === undefined)
+            clearTimeout(timer);
+        await joinJobs().then(() => {
+            clearTimeout(timer);
         });
-        ws.addEventListener('message', (event) => {
-            if (event.type !== 'message') {
-                this.logger.warn('unexpected message type: ' + event.type);
-                return;
+    }
+    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 room = await client.createRoom({ name: roomName });
+        let participant = undefined;
+        if (participantIdentity) {
+            try {
+                participant = await client.getParticipant(roomName, participantIdentity);
             }
-            const msg = new ServerMessage();
-            msg.fromBinary(event.data);
-            switch (msg.message.case) {
-                case 'register': {
-                    this.#id = msg.message.value.workerId;
-                    log
-                        .child({ id: this.id, server_info: msg.message.value.serverInfo })
-                        .info('registered worker');
-                    break;
-                }
-                case 'availability': {
-                    this.availability(msg.message.value);
-                    break;
-                }
-                case 'assignment': {
-                    const job = msg.message.value.job;
-                    if (job.id in this.pending) {
-                        const task = this.pending[job.id];
-                        delete this.pending[job.id];
-                        task.value.resolve({
-                            asgn: msg.message.value,
-                            raw: msg.toJsonString(),
-                        });
-                    }
-                    else {
-                        log.child({ job }).warn('received assignment for unknown job ' + job.id);
-                    }
-                    break;
-                }
+            catch (e) {
+                __classPrivateFieldGet(this, _Worker_logger, "f").fatal(`participant with identity ${participantIdentity} not found in room ${roomName}`);
+                throw e;
             }
-        });
+        }
         this.event.emit('worker_msg', new WorkerMessage({
             message: {
-                case: 'register',
+                case: 'simulateJob',
                 value: {
-                    type: this.opts.workerType,
-                    namespace: this.opts.namespace,
-                    allowedPermissions: new ParticipantPermission({
-                        canPublish: this.opts.permissions.canPublish,
-                        canSubscribe: this.opts.permissions.canSubscribe,
-                        canPublishData: this.opts.permissions.canPublishData,
-                        hidden: this.opts.permissions.hidden,
-                        agent: true,
-                    }),
-                    version,
+                    type: JobType.JT_PUBLISHER,
+                    room,
+                    participant,
                 },
             },
         }));
-        const loadMonitor = setInterval(() => {
-            if (closingWS)
-                clearInterval(loadMonitor);
+    }
+    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;
+            }
+            case 'availability': {
+                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;
+            }
+            case 'assignment': {
+                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);
+                }
+                else {
+                    __classPrivateFieldGet(this, _Worker_logger, "f").child({ job }).warn('received assignment for unknown job ' + job.id);
+                }
+                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');
+                }
+                else {
+                    __classPrivateFieldGet(this, _Worker_logger, "f").child(extra).info('worker is below capacity, marking as available');
+                }
+            }
             this.event.emit('worker_msg', new WorkerMessage({
                 message: {
                     case: 'updateWorker',
                     value: {
-                        load: cpuLoad(),
+                        load: currentLoad,
+                        status: currentStatus,
                     },
                 },
             }));
-        }, LOAD_INTERVAL);
-    }
-    async availability(msg) {
-        const tx = new EventEmitter();
-        const req = new JobRequest(msg.job, tx);
-        tx.on('recv', async (av) => {
-            const msg = new WorkerMessage({
-                message: {
-                    case: 'availability',
-                    value: {
-                        available: av.avail,
-                        jobId: req.id,
-                        participantIdentity: av.data?.identity,
-                        participantName: av.data?.name,
-                        participantMetadata: av.data?.metadata,
-                    },
+        });
+    }, 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',
+                value: {
+                    jobId: msg.job.id,
+                    available: false,
+                },
+            },
+        }));
+    };
+    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] = { value: new PendingAssignment() };
-            this.event.emit('worker_msg', msg);
-            if (!av.avail)
-                return;
-            const timer = setTimeout(() => {
-                log.child({ req }).warn(`assignment for job ${req.id} timed out`);
-                return;
-            }, ASSIGNMENT_TIMEOUT);
-            this.pending[req.id].value.promise.then(({ asgn, raw }) => {
-                clearTimeout(timer);
-                this.startProcess(asgn.job, av.data, raw);
-            });
+            },
+        }));
+        __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`);
+            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 {
-            this.opts.requestFunc(req);
+            await __classPrivateFieldGet(this, _Worker_opts, "f").requestFunc(req);
         }
         catch (e) {
-            log.child({ req }).error(`user request handler for job ${req.id} failed`);
-        }
-        finally {
-            if (!req.answered) {
-                log.child({ req }).error(`no answer for job ${req.id}, automatically rejecting the job`);
-                this.event.emit('worker_msg', new WorkerMessage({
-                    message: {
-                        case: 'availability',
-                        value: {
-                            available: false,
-                        },
-                    },
-                }));
-            }
+            __classPrivateFieldGet(this, _Worker_logger, "f")
+                .child({ job: msg.job, resuming: msg.resuming, agentName: __classPrivateFieldGet(this, _Worker_opts, "f").agentName })
+                .info('jobRequestFunc failed');
+            await onReject();
         }
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.logger.debug('shutting down worker');
-        await this.httpServer.close();
-        for await (const value of Object.values(this.processes)) {
-            await value.proc.close();
+        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');
         }
-        this.session?.close();
+    };
+    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;
     }
-}
+    await proc.close();
+};
 //# sourceMappingURL=worker.js.map