Worker options

opts = WorkerOptions(
    # entrypoint function is called when a job is assigned to this worker
    # this is the only required parameter to WorkerOptions
    # https://docs.livekit.io/agents/worker/job/#entrypoint
    entrypoint_fnc,
    # inspect the request and decide if the current worker should handle it.
    request_fnc,
    # a function to perform any necessary initialization in a new process.
    prewarm_fnc,
    # whether the agent can subscribe to tracks, publish data, update metadata, etc.
    permissions,
    # amount of time to wait for existing jobs to finish when SIGTERM or SIGINT is received
    drain_timeout,
    # the type of worker to create, either JT_ROOM or JT_PUBLISHER
    worker_type=WorkerType.ROOM,
    # a function that reports the current system load, whether CPU or RAM, etc.
    load_fnc,
    # the maximum value of load_fnc, above which no new processes will spawn
    load_threshold,
    # set the agent name to enable explicit dispatch.
    # https://docs.livekit.io/agents/worker/agent-dispatch/
    agent_name,
)

# start the worker
cli.run_app(opts)

const opts = new WorkerOptions({
  // path to a file that has {@link Agent} as a default export, dynamically imported later for
  // entrypoint and prewarm functions.
  agent,
  // inspect the request and decide if the current worker should handle it.
  requestFunc,
  // whether the agent can subscribe to tracks, publish data, update metadata, etc.
  permissions,
  // the type of worker to create, either JT_ROOM or JT_PUBLISHER
  workerType=JobType.JT_ROOM,
  // a function that reports the current load of the worker. returns a value between 0-1.
  loadFunc,
  // the maximum value of loadFunc, above which worker is marked as unavailable.
  loadThreshold,
  // set the agent name to enable explicit dispatch.
  // https://docs.livekit.io/agents/worker/agent-dispatch/
  agentName,
})

// Start the worker
cli.runApp(opts);

async def entrypoint(ctx: JobContext):
    # connect to the room

    # handle the session
    ...

export default defineAgent({
  entry: async (ctx: JobContext) => {
    // connect to the room
    await ctx.connect();
    // handle the session
  },
});

async def request_fnc(req: JobRequest):
    # accept the job request
    await req.accept(
        # the agent's name (Participant.name), defaults to ""
        name="agent",
        # the agent's identity (Participant.identity), defaults to "agent-<jobid>"
        identity="identity",
        # attributes to set on the agent participant upon join
        attributes={"myagent": "rocks"},
    )

    # or reject it
    # await req.reject()

opts = WorkerOptions(entrypoint_fnc=entrypoint, request_fnc=request_fnc)

const requestFunc = async (req: JobRequest) => {
  // accept the job request
  await req.accept(
    // the agent's name (Participant.name), defaults to ""
    'agent',
    // the agent's identity (Participant.identity), defaults to "agent-<jobid>"
    'identity',
  );
};

const opts = new WorkerOptions({
  // agent: ...
  requestFunc,
});

def prewarm_fnc(proc: JobProcess):
    # load silero weights and store to process userdata
    proc.userdata["vad"] = silero.VAD.load()


async def entrypoint(ctx: JobContext):
    # access the loaded silero instance
    vad: silero.VAD = ctx.proc.userdata["vad"]

opts = WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm_fnc)

export default defineAgent({
  prewarm: async (proc: JobProcess) => {
    // load silero weights and store to process userdata
    proc.userData.vad = await silero.VAD.load();
  },
  entry: async (ctx: JobContext) => {
    // access the loaded silero instance
    const vad = ctx.proc.userData.vad! as silero.VAD;
  },
});

from livekit.agents import Worker, WorkerOptions

def compute_load(worker: Worker) -> float:
    return min(len(worker.active_jobs) / 10, 1.0)

opts = WorkerOptions(
    load_fnc=compute_load,
    load_threshold=0.9,
)

import { Worker, WorkerOptions } from '@livekit/agents';

const computeLoad = (worker: Worker): Promise<number> => {
  return Math.min(worker.activeJobs.length / 10, 1.0);
};

const opts = new WorkerOptions({
  // agent: ...
  loadFunc: computeLoad,
  loadThreshold: 0.9,
});

opts = WorkerOptions(
    ...
    permissions=WorkerPermissions(
        can_publish=True,
        can_subscribe=True,
        can_publish_data=True,
        # when set to true, the agent won't be visible to others in the room.
        # when hidden, it will also not be able to publish tracks to the room as it won't be visible.
        hidden=False,
    ),
)

const opts = new WorkerOptions({
  // agent: ...
  permissions: new WorkerPermissions({
    canPublish: true,
    canSubscribe: true,
    // when set to true, the agent won't be visible to others in the room.
    // when hidden, it will also not be able to publish tracks to the room as it won't be visible
    hidden: false,
  }),
});

opts = WorkerOptions(
    ...
    # when omitted, the default is WorkerType.ROOM
    worker_type=WorkerType.ROOM,
)

const opts = new WorkerOptions({
  // agent: ...
  // when omitted, the default is JobType.JT_ROOM
  workerType: JobType.JT_ROOM,
});

if __name__ == "__main__":
    cli.run_app(opts)

cli.runApp(opts);

python agent.py start --log-level=DEBUG

pnpm run start --log-level=debug