@livekit/agents 1.1.0-dev.0 → 1.2.0

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;

package/dist/voice/client_events.cjs

@@ -1,554 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var client_events_exports = {};
-__export(client_events_exports, {
-  ClientEventsHandler: () => ClientEventsHandler,
-  RemoteSession: () => RemoteSession
-});
-module.exports = __toCommonJS(client_events_exports);
-var import_events = __toESM(require("events"), 1);
-var import_constants = require("../constants.cjs");
-var import_log = require("../log.cjs");
-var import_utils = require("../utils.cjs");
-var import_events2 = require("./events.cjs");
-var import_wire_format = require("./wire_format.cjs");
-function serializeOptions(opts) {
-  var _a, _b;
-  return {
-    endpointing: ((_a = opts.turnHandling) == null ? void 0 : _a.endpointing) ?? {},
-    interruption: ((_b = opts.turnHandling) == null ? void 0 : _b.interruption) ?? {},
-    max_tool_steps: opts.maxToolSteps,
-    user_away_timeout: opts.userAwayTimeout,
-    preemptive_generation: opts.preemptiveGeneration,
-    use_tts_aligned_transcript: opts.useTtsAlignedTranscript
-  };
-}
-function toolNames(toolCtx) {
-  if (!toolCtx) return [];
-  return Object.keys(toolCtx);
-}
-class ClientEventsHandler {
-  session;
-  roomIO;
-  textInputCb;
-  textStreamHandlerRegistered = false;
-  rpcHandlersRegistered = false;
-  requestHandlerRegistered = false;
-  eventHandlersRegistered = false;
-  started = false;
-  tasks = /* @__PURE__ */ new Set();
-  logger = (0, import_log.log)();
-  constructor(session, roomIO) {
-    this.session = session;
-    this.roomIO = roomIO;
-  }
-  get room() {
-    return this.roomIO.rtcRoom;
-  }
-  async start() {
-    if (this.started) return;
-    this.started = true;
-    this.registerRpcHandlers();
-    this.registerRequestHandler();
-    this.registerEventHandlers();
-  }
-  async close() {
-    if (!this.started) return;
-    this.started = false;
-    if (this.textStreamHandlerRegistered) {
-      this.room.unregisterTextStreamHandler(import_constants.TOPIC_CHAT);
-      this.textStreamHandlerRegistered = false;
-    }
-    if (this.rpcHandlersRegistered) {
-      const localParticipant = this.room.localParticipant;
-      if (localParticipant) {
-        localParticipant.unregisterRpcMethod(import_constants.RPC_GET_SESSION_STATE);
-        localParticipant.unregisterRpcMethod(import_constants.RPC_GET_CHAT_HISTORY);
-        localParticipant.unregisterRpcMethod(import_constants.RPC_GET_AGENT_INFO);
-        localParticipant.unregisterRpcMethod(import_constants.RPC_SEND_MESSAGE);
-      }
-      this.rpcHandlersRegistered = false;
-    }
-    if (this.requestHandlerRegistered) {
-      this.room.unregisterTextStreamHandler(import_constants.TOPIC_AGENT_REQUEST);
-      this.requestHandlerRegistered = false;
-    }
-    if (this.eventHandlersRegistered) {
-      this.session.off(import_events2.AgentSessionEventTypes.AgentStateChanged, this.onAgentStateChanged);
-      this.session.off(import_events2.AgentSessionEventTypes.UserStateChanged, this.onUserStateChanged);
-      this.session.off(import_events2.AgentSessionEventTypes.ConversationItemAdded, this.onConversationItemAdded);
-      this.session.off(import_events2.AgentSessionEventTypes.FunctionToolsExecuted, this.onFunctionToolsExecuted);
-      this.session.off(import_events2.AgentSessionEventTypes.MetricsCollected, this.onMetricsCollected);
-      this.session.off(import_events2.AgentSessionEventTypes.UserInputTranscribed, this.onUserInputTranscribed);
-      this.session.off(import_events2.AgentSessionEventTypes.UserOverlappingSpeech, this.onUserOverlapSpeech);
-      this.session.off(import_events2.AgentSessionEventTypes.Error, this.onError);
-      this.eventHandlersRegistered = false;
-    }
-    await (0, import_utils.cancelAndWait)([...this.tasks]);
-    this.tasks.clear();
-  }
-  /**
-   * Registers a callback to handle text input from clients.
-   *
-   * This callback will be called when a client sends a text message to the agent.
-   * The callback should return a promise that resolves when the text input has been processed.
-   *
-   * @param textInputCb - The callback to handle text input.
-   */
-  registerTextInput(textInputCb) {
-    this.textInputCb = textInputCb;
-    if (this.textStreamHandlerRegistered) return;
-    this.room.registerTextStreamHandler(import_constants.TOPIC_CHAT, this.onUserTextInput);
-    this.textStreamHandlerRegistered = true;
-  }
-  registerRpcHandlers() {
-    if (this.rpcHandlersRegistered) return;
-    const localParticipant = this.room.localParticipant;
-    if (!localParticipant) return;
-    localParticipant.registerRpcMethod(import_constants.RPC_GET_SESSION_STATE, this.rpcGetSessionState);
-    localParticipant.registerRpcMethod(import_constants.RPC_GET_CHAT_HISTORY, this.rpcGetChatHistory);
-    localParticipant.registerRpcMethod(import_constants.RPC_GET_AGENT_INFO, this.rpcGetAgentInfo);
-    localParticipant.registerRpcMethod(import_constants.RPC_SEND_MESSAGE, this.rpcSendMessage);
-    this.rpcHandlersRegistered = true;
-  }
-  registerRequestHandler() {
-    if (this.requestHandlerRegistered) return;
-    this.room.registerTextStreamHandler(import_constants.TOPIC_AGENT_REQUEST, this.onStreamRequest);
-    this.requestHandlerRegistered = true;
-  }
-  registerEventHandlers() {
-    if (this.eventHandlersRegistered) return;
-    this.session.on(import_events2.AgentSessionEventTypes.AgentStateChanged, this.onAgentStateChanged);
-    this.session.on(import_events2.AgentSessionEventTypes.UserStateChanged, this.onUserStateChanged);
-    this.session.on(import_events2.AgentSessionEventTypes.ConversationItemAdded, this.onConversationItemAdded);
-    this.session.on(import_events2.AgentSessionEventTypes.FunctionToolsExecuted, this.onFunctionToolsExecuted);
-    this.session.on(import_events2.AgentSessionEventTypes.MetricsCollected, this.onMetricsCollected);
-    this.session.on(import_events2.AgentSessionEventTypes.UserInputTranscribed, this.onUserInputTranscribed);
-    this.session.on(import_events2.AgentSessionEventTypes.UserOverlappingSpeech, this.onUserOverlapSpeech);
-    this.session.on(import_events2.AgentSessionEventTypes.Error, this.onError);
-    this.eventHandlersRegistered = true;
-  }
-  onStreamRequest = (reader, participantInfo) => {
-    const task = import_utils.Task.from(async () => this.handleStreamRequest(reader, participantInfo.identity));
-    this.trackTask(task);
-  };
-  async handleStreamRequest(reader, participantIdentity) {
-    try {
-      const data = await reader.readAll();
-      const request = import_wire_format.streamRequestSchema.parse(JSON.parse(data));
-      let responsePayload = "";
-      let error = null;
-      try {
-        switch (request.method) {
-          case "get_session_state":
-            responsePayload = await this.streamGetSessionState();
-            break;
-          case "get_chat_history":
-            responsePayload = await this.streamGetChatHistory();
-            break;
-          case "get_agent_info":
-            responsePayload = await this.streamGetAgentInfo();
-            break;
-          case "send_message":
-            responsePayload = await this.streamSendMessage(request.payload);
-            break;
-          case "get_rtc_stats":
-            responsePayload = await this.streamGetRtcStats();
-            break;
-          case "get_session_usage":
-            responsePayload = await this.streamGetSessionUsage();
-            break;
-          default:
-            error = `Unknown method: ${request.method}`;
-        }
-      } catch (e) {
-        error = e instanceof Error ? e.message : String(e);
-      }
-      const response = {
-        request_id: request.request_id,
-        payload: responsePayload,
-        error
-      };
-      const localParticipant = this.room.localParticipant;
-      await localParticipant.sendText(JSON.stringify(response), {
-        topic: import_constants.TOPIC_AGENT_RESPONSE,
-        destinationIdentities: [participantIdentity]
-      });
-    } catch (e) {
-      this.logger.warn({ error: e }, "failed to handle stream request");
-    }
-  }
-  async streamGetSessionState() {
-    const agent = this.session.currentAgent;
-    const response = {
-      agent_state: this.session.agentState,
-      user_state: this.session.userState,
-      agent_id: agent.id,
-      options: serializeOptions({
-        turnHandling: this.session.options.turnHandling,
-        maxToolSteps: this.session.options.maxToolSteps,
-        userAwayTimeout: this.session.options.userAwayTimeout,
-        preemptiveGeneration: this.session.options.preemptiveGeneration,
-        useTtsAlignedTranscript: this.session.options.useTtsAlignedTranscript
-      }),
-      created_at: (0, import_wire_format.msToS)(this.session._startedAt ?? Date.now())
-    };
-    return JSON.stringify(response);
-  }
-  async streamGetChatHistory() {
-    return JSON.stringify({
-      items: this.session.history.items.map(import_wire_format.chatItemToWire)
-    });
-  }
-  async streamGetAgentInfo() {
-    const agent = this.session.currentAgent;
-    return JSON.stringify({
-      id: agent.id,
-      instructions: agent.instructions,
-      tools: toolNames(agent.toolCtx),
-      chat_ctx: agent.chatCtx.items.map(import_wire_format.chatItemToWire)
-    });
-  }
-  async streamSendMessage(payload) {
-    const request = import_wire_format.sendMessageRequestSchema.parse(JSON.parse(payload));
-    const runResult = this.session.run({ userInput: request.text });
-    await runResult.wait();
-    return JSON.stringify({
-      items: runResult.events.map((ev) => (0, import_wire_format.chatItemToWire)(ev.item))
-    });
-  }
-  async streamGetRtcStats() {
-    return JSON.stringify({
-      publisher_stats: [],
-      subscriber_stats: []
-    });
-  }
-  async streamGetSessionUsage() {
-    return JSON.stringify({
-      usage: (0, import_wire_format.agentSessionUsageToWire)(this.session.usage),
-      created_at: (0, import_wire_format.msToS)(Date.now())
-    });
-  }
-  onUserOverlapSpeech = (event) => {
-    const clientEvent = {
-      type: "user_overlapping_speech",
-      is_interruption: event.isInterruption,
-      created_at: (0, import_wire_format.msToS)(event.timestamp),
-      overlap_started_at: event.overlapStartedAt != null ? (0, import_wire_format.msToS)(event.overlapStartedAt) : null,
-      detection_delay: event.detectionDelayInS,
-      sent_at: (0, import_wire_format.msToS)(Date.now())
-    };
-    this.streamClientEvent(clientEvent);
-  };
-  onAgentStateChanged = (event) => {
-    const clientEvent = {
-      type: "agent_state_changed",
-      old_state: event.oldState,
-      new_state: event.newState,
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    };
-    this.streamClientEvent(clientEvent);
-  };
-  onUserStateChanged = (event) => {
-    const clientEvent = {
-      type: "user_state_changed",
-      old_state: event.oldState,
-      new_state: event.newState,
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    };
-    this.streamClientEvent(clientEvent);
-  };
-  onConversationItemAdded = (event) => {
-    if (event.item.type !== "message") {
-      return;
-    }
-    this.streamClientEvent({
-      type: "conversation_item_added",
-      item: (0, import_wire_format.chatMessageToWire)(event.item),
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    });
-  };
-  onUserInputTranscribed = (event) => {
-    this.streamClientEvent({
-      type: "user_input_transcribed",
-      transcript: event.transcript,
-      is_final: event.isFinal,
-      language: event.language,
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    });
-  };
-  onFunctionToolsExecuted = (event) => {
-    this.streamClientEvent({
-      type: "function_tools_executed",
-      function_calls: event.functionCalls.map(
-        import_wire_format.functionCallToWire
-      ),
-      function_call_outputs: event.functionCallOutputs.map(
-        (o) => o ? (0, import_wire_format.functionCallOutputToWire)(o) : null
-      ),
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    });
-  };
-  onMetricsCollected = (event) => {
-    this.streamClientEvent({
-      type: "metrics_collected",
-      metrics: (0, import_wire_format.agentMetricsToWire)(event.metrics),
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    });
-    this.streamClientEvent({
-      type: "session_usage",
-      usage: (0, import_wire_format.agentSessionUsageToWire)(this.session.usage),
-      created_at: (0, import_wire_format.msToS)(Date.now())
-    });
-  };
-  onError = (event) => {
-    const clientEvent = {
-      type: "error",
-      message: event.error ? String(event.error) : "Unknown error",
-      created_at: (0, import_wire_format.msToS)(event.createdAt)
-    };
-    this.streamClientEvent(clientEvent);
-  };
-  getTargetIdentities() {
-    const linked = this.roomIO.linkedParticipant;
-    return linked ? [linked.identity] : null;
-  }
-  streamClientEvent(event) {
-    const task = import_utils.Task.from(async () => this.sendClientEvent(event));
-    this.trackTask(task);
-  }
-  async sendClientEvent(event) {
-    if (!this.room.isConnected) return;
-    const destinationIdentities = this.getTargetIdentities();
-    if (!destinationIdentities) return;
-    try {
-      const localParticipant = this.room.localParticipant;
-      if (!localParticipant) return;
-      const writer = await localParticipant.streamText({
-        topic: import_constants.TOPIC_CLIENT_EVENTS,
-        destinationIdentities
-      });
-      await writer.write(JSON.stringify(event));
-      await writer.close();
-    } catch (e) {
-      this.logger.warn({ error: e }, "failed to stream event to clients");
-    }
-  }
-  rpcGetSessionState = async () => {
-    return this.streamGetSessionState();
-  };
-  rpcGetChatHistory = async () => {
-    return this.streamGetChatHistory();
-  };
-  rpcGetAgentInfo = async () => {
-    return this.streamGetAgentInfo();
-  };
-  rpcSendMessage = async (data) => {
-    return this.streamSendMessage(data.payload);
-  };
-  onUserTextInput = (reader, participantInfo) => {
-    const linkedParticipant = this.roomIO.linkedParticipant;
-    if (linkedParticipant && participantInfo.identity !== linkedParticipant.identity) {
-      return;
-    }
-    const participant = this.room.remoteParticipants.get(participantInfo.identity);
-    if (!participant) {
-      this.logger.warn("participant not found, ignoring text input");
-      return;
-    }
-    if (!this.textInputCb) {
-      this.logger.error("text input callback is not set, ignoring text input");
-      return;
-    }
-    const task = import_utils.Task.from(async () => {
-      const text = await reader.readAll();
-      const result = this.textInputCb(this.session, {
-        text,
-        info: reader.info,
-        participantIdentity: participantInfo.identity
-      });
-      if (result instanceof Promise) {
-        await result;
-      }
-    });
-    this.trackTask(task);
-  };
-  trackTask(task) {
-    this.tasks.add(task);
-    task.addDoneCallback(() => {
-      this.tasks.delete(task);
-    });
-  }
-}
-class RemoteSession extends import_events.default {
-  room;
-  agentIdentity;
-  started = false;
-  tasks = /* @__PURE__ */ new Set();
-  pendingRequests = /* @__PURE__ */ new Map();
-  logger = (0, import_log.log)();
-  constructor(room, agentIdentity) {
-    super();
-    this.room = room;
-    this.agentIdentity = agentIdentity;
-  }
-  async start() {
-    if (this.started) return;
-    this.started = true;
-    this.room.registerTextStreamHandler(import_constants.TOPIC_CLIENT_EVENTS, this.onEventStream);
-    this.room.registerTextStreamHandler(import_constants.TOPIC_AGENT_RESPONSE, this.onResponseStream);
-  }
-  async close() {
-    if (!this.started) return;
-    this.started = false;
-    this.room.unregisterTextStreamHandler(import_constants.TOPIC_CLIENT_EVENTS);
-    this.room.unregisterTextStreamHandler(import_constants.TOPIC_AGENT_RESPONSE);
-    for (const pending of this.pendingRequests.values()) {
-      pending.reject(new Error("RemoteSession closed"));
-    }
-    this.pendingRequests.clear();
-    await (0, import_utils.cancelAndWait)([...this.tasks]);
-    this.tasks.clear();
-  }
-  onEventStream = (reader, participantInfo) => {
-    if (participantInfo.identity !== this.agentIdentity) return;
-    this.trackTask(import_utils.Task.from(async () => this.readEvent(reader)));
-  };
-  onResponseStream = (reader, participantInfo) => {
-    if (participantInfo.identity !== this.agentIdentity) return;
-    this.trackTask(import_utils.Task.from(async () => this.readResponse(reader)));
-  };
-  async readResponse(reader) {
-    try {
-      const data = await reader.readAll();
-      const response = import_wire_format.streamResponseSchema.parse(JSON.parse(data));
-      const future = this.pendingRequests.get(response.request_id);
-      this.pendingRequests.delete(response.request_id);
-      if (!future || future.done) return;
-      future.resolve(response);
-    } catch (e) {
-      this.logger.warn({ error: e }, "failed to read stream response");
-    }
-  }
-  async readEvent(reader) {
-    try {
-      const data = await reader.readAll();
-      const event = this.parseEvent(data);
-      if (event) {
-        this.emit(event.type, event);
-      }
-    } catch (e) {
-      this.logger.warn({ error: e }, "failed to parse client event");
-    }
-  }
-  parseEvent(data) {
-    try {
-      const result = import_wire_format.clientEventSchema.safeParse(JSON.parse(data));
-      if (!result.success) {
-        this.logger.warn({ error: result.error }, "failed to validate event");
-        return null;
-      }
-      return result.data;
-    } catch (e) {
-      this.logger.warn({ error: e }, "failed to parse event");
-      return null;
-    }
-  }
-  async sendRequest(method, payload, timeout = 6e4) {
-    const requestId = (0, import_utils.shortuuid)("req_");
-    const request = {
-      request_id: requestId,
-      method,
-      payload
-    };
-    const future = new import_utils.Future();
-    this.pendingRequests.set(requestId, future);
-    const localParticipant = this.room.localParticipant;
-    if (!localParticipant) {
-      this.pendingRequests.delete(requestId);
-      throw new Error("RemoteSession room has no local participant");
-    }
-    await localParticipant.sendText(JSON.stringify(request), {
-      topic: import_constants.TOPIC_AGENT_REQUEST,
-      destinationIdentities: [this.agentIdentity]
-    });
-    const timer = setTimeout(() => {
-      if (!future.done) {
-        this.pendingRequests.delete(requestId);
-        future.reject(new Error(`RemoteSession request timed out: ${method}`));
-      }
-    }, timeout);
-    try {
-      const response = await future.await;
-      if (response.error) {
-        throw new Error(response.error);
-      }
-      return response.payload;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  async fetchSessionState() {
-    const raw = JSON.parse(await this.sendRequest("get_session_state", "{}"));
-    return import_wire_format.getSessionStateResponseSchema.parse(raw);
-  }
-  async fetchChatHistory() {
-    const raw = JSON.parse(await this.sendRequest("get_chat_history", "{}"));
-    return import_wire_format.getChatHistoryResponseSchema.parse(raw);
-  }
-  async fetchAgentInfo() {
-    const raw = JSON.parse(await this.sendRequest("get_agent_info", "{}"));
-    return import_wire_format.getAgentInfoResponseSchema.parse(raw);
-  }
-  async sendMessage(text, responseTimeout = 6e4) {
-    const payload = JSON.stringify({ text });
-    const raw = JSON.parse(await this.sendRequest("send_message", payload, responseTimeout));
-    return import_wire_format.sendMessageResponseSchema.parse(raw);
-  }
-  async fetchRtcStats() {
-    const raw = JSON.parse(await this.sendRequest("get_rtc_stats", "{}"));
-    return import_wire_format.getRTCStatsResponseSchema.parse(raw);
-  }
-  async fetchSessionUsage() {
-    const raw = JSON.parse(await this.sendRequest("get_session_usage", "{}"));
-    return import_wire_format.getSessionUsageResponseSchema.parse(raw);
-  }
-  trackTask(task) {
-    this.tasks.add(task);
-    task.addDoneCallback(() => {
-      this.tasks.delete(task);
-    });
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ClientEventsHandler,
-  RemoteSession
-});
-//# sourceMappingURL=client_events.cjs.map