@livekit/agents 1.0.47 → 1.0.49

package/src/voice/room_io/room_io.ts

@@ -21,7 +21,7 @@ import type { WritableStreamDefaultWriter } from 'node:stream/web';
 import { ATTRIBUTE_PUBLISH_ON_BEHALF, TOPIC_CHAT } from '../../constants.js';
 import { log } from '../../log.js';
 import { IdentityTransform } from '../../stream/identity_transform.js';
-import { Future, Task } from '../../utils.js';
+import { Future, Task, waitForAbort } from '../../utils.js';
 import { type AgentSession } from '../agent_session.js';
 import {
   AgentSessionEventTypes,
@@ -177,7 +177,10 @@ export class RoomIO {
       : this.inputOptions.participantIdentity ?? null;
   }
   private async init(signal: AbortSignal): Promise<void> {
-    await this.roomConnectedFuture.await;
+    await Promise.race([this.roomConnectedFuture.await, waitForAbort(signal)]);
+    if (signal.aborted) {
+      return;
+    }
 
     for (const participant of this.room.remoteParticipants.values()) {
       this.onParticipantConnected(participant);
@@ -186,7 +189,15 @@ export class RoomIO {
       return;
     }
 
-    const participant = await this.participantAvailableFuture.await;
+    const participant = await Promise.race([
+      this.participantAvailableFuture.await,
+      waitForAbort(signal),
+    ]);
+
+    if (!participant) {
+      return;
+    }
+
     this.setParticipant(participant.identity);
 
     // init agent outputs

package/src/voice/testing/fake_llm.ts

@@ -0,0 +1,138 @@
+// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { ChatContext } from '../../llm/chat_context.js';
+import { FunctionCall } from '../../llm/chat_context.js';
+import { LLMStream as BaseLLMStream, LLM, type LLMStream } from '../../llm/llm.js';
+import type { ToolChoice, ToolContext } from '../../llm/tool_context.js';
+import { type APIConnectOptions, DEFAULT_API_CONNECT_OPTIONS } from '../../types.js';
+import { delay } from '../../utils.js';
+
+export interface FakeLLMResponse {
+  input: string;
+  type?: 'llm';
+  content?: string;
+  ttft?: number;
+  duration?: number;
+  toolCalls?: Array<{ name: string; args: Record<string, unknown> }>;
+}
+
+export class FakeLLM extends LLM {
+  private readonly responseMap = new Map<string, FakeLLMResponse>();
+
+  constructor(responses: FakeLLMResponse[] = []) {
+    super();
+    for (const response of responses) {
+      this.responseMap.set(response.input, {
+        type: 'llm',
+        ttft: 0,
+        duration: 0,
+        ...response,
+      });
+    }
+  }
+
+  label(): string {
+    return 'fake-llm';
+  }
+
+  chat({
+    chatCtx,
+    toolCtx,
+    connOptions = DEFAULT_API_CONNECT_OPTIONS,
+  }: {
+    chatCtx: ChatContext;
+    toolCtx?: ToolContext;
+    connOptions?: APIConnectOptions;
+    parallelToolCalls?: boolean;
+    toolChoice?: ToolChoice;
+    extraKwargs?: Record<string, unknown>;
+  }): LLMStream {
+    return new FakeLLMStream(this, {
+      chatCtx,
+      toolCtx,
+      connOptions,
+    });
+  }
+
+  lookup(input: string): FakeLLMResponse | undefined {
+    return this.responseMap.get(input);
+  }
+}
+
+class FakeLLMStream extends BaseLLMStream {
+  private readonly fake: FakeLLM;
+
+  constructor(
+    fake: FakeLLM,
+    params: { chatCtx: ChatContext; toolCtx?: ToolContext; connOptions: APIConnectOptions },
+  ) {
+    super(fake, params);
+    this.fake = fake;
+  }
+
+  protected async run(): Promise<void> {
+    const input = this.getInputText();
+    const decision = this.fake.lookup(input);
+    if (!decision) {
+      return;
+    }
+
+    const startedAt = Date.now();
+    if ((decision.ttft ?? 0) > 0) {
+      await delay(decision.ttft!);
+    }
+
+    const content = decision.content ?? '';
+    const chunkSize = 3;
+    for (let i = 0; i < content.length; i += chunkSize) {
+      this.queue.put({
+        id: 'fake',
+        delta: { role: 'assistant', content: content.slice(i, i + chunkSize) },
+      });
+    }
+
+    if (decision.toolCalls && decision.toolCalls.length > 0) {
+      const calls = decision.toolCalls.map((tc, index) =>
+        FunctionCall.create({
+          callId: `fake_call_${index}`,
+          name: tc.name,
+          args: JSON.stringify(tc.args),
+        }),
+      );
+      this.queue.put({
+        id: 'fake',
+        delta: { role: 'assistant', toolCalls: calls },
+      });
+    }
+
+    const elapsed = Date.now() - startedAt;
+    const waitMs = Math.max(0, (decision.duration ?? 0) - elapsed);
+    if (waitMs > 0) {
+      await delay(waitMs);
+    }
+  }
+
+  private getInputText(): string {
+    const items = this.chatCtx.items;
+    if (items.length === 0) {
+      throw new Error('No input text found');
+    }
+
+    for (const item of items) {
+      if (item.type === 'message' && item.role === 'system') {
+        const text = item.textContent ?? '';
+        const lines = text.split('\n');
+        const tail = lines[lines.length - 1] ?? '';
+        if (lines.length > 1 && tail.startsWith('instructions:')) {
+          return tail;
+        }
+      }
+    }
+
+    const last = items[items.length - 1]!;
+    if (last.type === 'message' && last.role === 'user') return last.textContent ?? '';
+    if (last.type === 'function_call_output') return last.output;
+    throw new Error('No input text found');
+  }
+}

package/src/voice/testing/index.ts

@@ -48,3 +48,5 @@ export {
   type MessageAssertOptions,
   type RunEvent,
 } from './types.js';
+
+export { FakeLLM, type FakeLLMResponse } from './fake_llm.js';

package/src/worker.ts

@@ -13,8 +13,8 @@ import {
 import type { ParticipantInfo } from 'livekit-server-sdk';
 import { AccessToken, RoomServiceClient } from 'livekit-server-sdk';
 import { EventEmitter } from 'node:events';
-import os from 'node:os';
 import { WebSocket } from 'ws';
+import { getCpuMonitor } from './cpu.js';
 import { HTTPServer } from './http_server.js';
 import { InferenceRunner } from './inference_runner.js';
 import { InferenceProcExecutor } from './ipc/inference_proc_executor.js';
@@ -79,32 +79,11 @@ const defaultRequestFunc = async (ctx: JobRequest) => {
   await ctx.accept();
 };
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const defaultCpuLoad = async (worker: AgentServer): Promise<number> => {
-  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);
+const cpuMonitor = getCpuMonitor();
 
-        total += total2 - total1;
-      }
-
-      resolve(+(1 - idle / total).toFixed(2));
-    }, UPDATE_LOAD_INTERVAL);
-  });
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const defaultCpuLoad = async (_worker: AgentServer): Promise<number> => {
+  return cpuMonitor.cpuPercent(UPDATE_LOAD_INTERVAL);
 };
 
 /** Participant permissions to pass to every agent spun up by this worker. */
@@ -651,33 +630,38 @@ export class AgentServer {
       if (closingWS) clearInterval(loadMonitor);
 
       const oldStatus = currentStatus;
-      this.#opts.loadFunc(this).then((currentLoad: number) => {
-        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.#opts
+        .loadFunc(this)
+        .then((currentLoad: number) => {
+          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,
+          this.event.emit(
+            'worker_msg',
+            new WorkerMessage({
+              message: {
+                case: 'updateWorker',
+                value: {
+                  load: currentLoad,
+                  status: currentStatus,
+                },
               },
-            },
-          }),
-        );
-      });
+            }),
+          );
+        })
+        .catch((e) => {
+          this.#logger.warn({ error: e }, 'failed to measure CPU load');
+        });
     }, UPDATE_LOAD_INTERVAL);
 
     await close;