@livekit/agents 1.1.0-dev.0 → 1.2.0

package/dist/voice/remote_session.js

@@ -0,0 +1,887 @@
+import { Timestamp } from "@bufbuild/protobuf";
+import { AgentSession as pb } from "@livekit/protocol";
+import EventEmitter from "events";
+import { TOPIC_SESSION_MESSAGES } from "../constants.js";
+import { log } from "../log.js";
+import { Future, Task, shortuuid } from "../utils.js";
+import {
+  AgentSessionEventTypes
+} from "./events.js";
+class SessionTransport {
+  async start() {
+  }
+}
+class RoomSessionTransport extends SessionTransport {
+  room;
+  handlerRegistered = false;
+  closed = false;
+  pendingMessages = [];
+  waitingResolve = null;
+  roomIO;
+  constructor(room, roomIO) {
+    super();
+    this.room = room;
+    this.roomIO = roomIO;
+  }
+  getRemoteIdentity() {
+    var _a;
+    return (_a = this.roomIO.linkedParticipant) == null ? void 0 : _a.identity;
+  }
+  async start() {
+    if (this.handlerRegistered) return;
+    this.room.registerByteStreamHandler(TOPIC_SESSION_MESSAGES, this.onByteStream);
+    this.handlerRegistered = true;
+  }
+  onByteStream = (reader, participantInfo) => {
+    if (this.getRemoteIdentity() && participantInfo.identity !== this.getRemoteIdentity()) {
+      return;
+    }
+    this.readStream(reader).catch((e) => {
+      log().warn({ error: e }, "failed to read binary stream message");
+    });
+  };
+  async readStream(reader) {
+    try {
+      const chunks = await reader.readAll();
+      let totalLength = 0;
+      for (const chunk of chunks) {
+        totalLength += chunk.length;
+      }
+      const data = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        data.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const msg = pb.AgentSessionMessage.fromBinary(data);
+      this.enqueue(msg);
+    } catch (e) {
+      if (!this.closed) {
+        log().warn({ error: e }, "failed to parse binary stream message");
+      }
+    }
+  }
+  async sendMessage(msg) {
+    if (this.closed || !this.room.isConnected) return;
+    try {
+      const data = msg.toBinary();
+      const opts = {
+        topic: TOPIC_SESSION_MESSAGES,
+        name: shortuuid("AS_")
+      };
+      const remoteIdentity = this.getRemoteIdentity();
+      if (remoteIdentity) {
+        opts.destinationIdentities = [remoteIdentity];
+      }
+      const writer = await this.room.localParticipant.streamBytes(opts);
+      await writer.write(new Uint8Array(data));
+      await writer.close();
+    } catch (e) {
+      log().warn({ error: e }, "failed to send binary stream message");
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.handlerRegistered) {
+      try {
+        this.room.unregisterByteStreamHandler(TOPIC_SESSION_MESSAGES);
+      } catch (e) {
+        log().debug({ error: e }, "byte stream handler already unregistered");
+      }
+      this.handlerRegistered = false;
+    }
+    if (this.waitingResolve) {
+      this.waitingResolve({
+        value: void 0,
+        done: true
+      });
+      this.waitingResolve = null;
+    }
+  }
+  enqueue(msg) {
+    if (this.closed) return;
+    if (this.waitingResolve) {
+      const resolve = this.waitingResolve;
+      this.waitingResolve = null;
+      resolve({ value: msg, done: false });
+    } else {
+      this.pendingMessages.push(msg);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.closed && this.pendingMessages.length === 0) {
+          return Promise.resolve({
+            value: void 0,
+            done: true
+          });
+        }
+        const pending = this.pendingMessages.shift();
+        if (pending) {
+          return Promise.resolve({ value: pending, done: false });
+        }
+        return new Promise((resolve) => {
+          this.waitingResolve = resolve;
+        });
+      },
+      return: () => {
+        this.close();
+        return Promise.resolve({
+          value: void 0,
+          done: true
+        });
+      }
+    };
+  }
+}
+const AGENT_STATE_MAP = {
+  initializing: pb.AgentState.AS_INITIALIZING,
+  idle: pb.AgentState.AS_IDLE,
+  listening: pb.AgentState.AS_LISTENING,
+  thinking: pb.AgentState.AS_THINKING,
+  speaking: pb.AgentState.AS_SPEAKING
+};
+const USER_STATE_MAP = {
+  speaking: pb.UserState.US_SPEAKING,
+  listening: pb.UserState.US_LISTENING,
+  away: pb.UserState.US_AWAY
+};
+function msToTimestamp(ms) {
+  return Timestamp.fromDate(new Date(ms));
+}
+function nowTimestamp() {
+  return Timestamp.fromDate(/* @__PURE__ */ new Date());
+}
+function chatItemToProto(item) {
+  switch (item.type) {
+    case "message": {
+      const msg = item;
+      const roleMap = {
+        developer: pb.ChatRole.DEVELOPER,
+        system: pb.ChatRole.SYSTEM,
+        user: pb.ChatRole.USER,
+        assistant: pb.ChatRole.ASSISTANT
+      };
+      const content = [];
+      for (const c of msg.content) {
+        if (typeof c === "string") {
+          content.push(new pb.ChatMessage_ChatContent({ payload: { case: "text", value: c } }));
+        }
+      }
+      const metricsReport = new pb.MetricsReport();
+      if (msg.metrics.transcriptionDelay !== void 0)
+        metricsReport.transcriptionDelay = msg.metrics.transcriptionDelay;
+      if (msg.metrics.endOfTurnDelay !== void 0)
+        metricsReport.endOfTurnDelay = msg.metrics.endOfTurnDelay;
+      if (msg.metrics.onUserTurnCompletedDelay !== void 0)
+        metricsReport.onUserTurnCompletedDelay = msg.metrics.onUserTurnCompletedDelay;
+      if (msg.metrics.llmNodeTtft !== void 0)
+        metricsReport.llmNodeTtft = msg.metrics.llmNodeTtft;
+      if (msg.metrics.ttsNodeTtfb !== void 0)
+        metricsReport.ttsNodeTtfb = msg.metrics.ttsNodeTtfb;
+      if (msg.metrics.e2eLatency !== void 0) metricsReport.e2eLatency = msg.metrics.e2eLatency;
+      const pbMsg = new pb.ChatMessage({
+        id: msg.id,
+        role: roleMap[msg.role] ?? pb.ChatRole.ASSISTANT,
+        content,
+        interrupted: msg.interrupted,
+        metrics: metricsReport,
+        createdAt: msToTimestamp(msg.createdAt)
+      });
+      if (msg.transcriptConfidence !== void 0) {
+        pbMsg.transcriptConfidence = msg.transcriptConfidence;
+      }
+      return new pb.ChatContext_ChatItem({ item: { case: "message", value: pbMsg } });
+    }
+    case "function_call": {
+      const fc = item;
+      return new pb.ChatContext_ChatItem({
+        item: {
+          case: "functionCall",
+          value: new pb.FunctionCall({
+            id: fc.id,
+            callId: fc.callId,
+            name: fc.name,
+            arguments: fc.args,
+            createdAt: msToTimestamp(fc.createdAt)
+          })
+        }
+      });
+    }
+    case "function_call_output": {
+      const fco = item;
+      return new pb.ChatContext_ChatItem({
+        item: {
+          case: "functionCallOutput",
+          value: new pb.FunctionCallOutput({
+            id: fco.id,
+            callId: fco.callId,
+            name: fco.name,
+            output: fco.output,
+            isError: fco.isError,
+            createdAt: msToTimestamp(fco.createdAt)
+          })
+        }
+      });
+    }
+    case "agent_handoff": {
+      const ah = item;
+      return new pb.ChatContext_ChatItem({
+        item: {
+          case: "agentHandoff",
+          value: new pb.AgentHandoff({
+            id: ah.id,
+            oldAgentId: ah.oldAgentId,
+            newAgentId: ah.newAgentId,
+            createdAt: msToTimestamp(ah.createdAt)
+          })
+        }
+      });
+    }
+  }
+}
+function sessionUsageToProto(usage) {
+  const modelUsages = [];
+  for (const mu of usage.modelUsage) {
+    switch (mu.type) {
+      case "llm_usage": {
+        const lu = mu;
+        modelUsages.push(
+          new pb.ModelUsage({
+            usage: {
+              case: "llm",
+              value: new pb.LLMModelUsage({
+                provider: lu.provider ?? "",
+                model: lu.model ?? "",
+                inputTokens: lu.inputTokens ?? 0,
+                inputCachedTokens: lu.inputCachedTokens ?? 0,
+                inputAudioTokens: lu.inputAudioTokens ?? 0,
+                inputCachedAudioTokens: lu.inputCachedAudioTokens ?? 0,
+                inputTextTokens: lu.inputTextTokens ?? 0,
+                inputCachedTextTokens: lu.inputCachedTextTokens ?? 0,
+                inputImageTokens: lu.inputImageTokens ?? 0,
+                inputCachedImageTokens: lu.inputCachedImageTokens ?? 0,
+                outputTokens: lu.outputTokens ?? 0,
+                outputAudioTokens: lu.outputAudioTokens ?? 0,
+                outputTextTokens: lu.outputTextTokens ?? 0,
+                sessionDuration: (lu.sessionDurationMs ?? 0) / 1e3
+              })
+            }
+          })
+        );
+        break;
+      }
+      case "tts_usage": {
+        const tu = mu;
+        modelUsages.push(
+          new pb.ModelUsage({
+            usage: {
+              case: "tts",
+              value: new pb.TTSModelUsage({
+                provider: tu.provider ?? "",
+                model: tu.model ?? "",
+                inputTokens: tu.inputTokens ?? 0,
+                outputTokens: tu.outputTokens ?? 0,
+                charactersCount: tu.charactersCount ?? 0,
+                audioDuration: (tu.audioDurationMs ?? 0) / 1e3
+              })
+            }
+          })
+        );
+        break;
+      }
+      case "stt_usage": {
+        const su = mu;
+        modelUsages.push(
+          new pb.ModelUsage({
+            usage: {
+              case: "stt",
+              value: new pb.STTModelUsage({
+                provider: su.provider ?? "",
+                model: su.model ?? "",
+                inputTokens: su.inputTokens ?? 0,
+                outputTokens: su.outputTokens ?? 0,
+                audioDuration: (su.audioDurationMs ?? 0) / 1e3
+              })
+            }
+          })
+        );
+        break;
+      }
+      case "interruption_usage": {
+        const iu = mu;
+        modelUsages.push(
+          new pb.ModelUsage({
+            usage: {
+              case: "interruption",
+              value: new pb.InterruptionModelUsage({
+                provider: iu.provider ?? "",
+                model: iu.model ?? "",
+                totalRequests: iu.totalRequests ?? 0
+              })
+            }
+          })
+        );
+        break;
+      }
+    }
+  }
+  return new pb.AgentSessionUsage({ modelUsage: modelUsages });
+}
+function toolNames(toolCtx) {
+  if (!toolCtx) return [];
+  return Object.keys(toolCtx);
+}
+function protoSerializeOptions(opts) {
+  var _a, _b;
+  return {
+    endpointing: JSON.stringify(((_a = opts.turnHandling) == null ? void 0 : _a.endpointing) ?? {}),
+    interruption: JSON.stringify(((_b = opts.turnHandling) == null ? void 0 : _b.interruption) ?? {}),
+    max_tool_steps: String(opts.maxToolSteps ?? 0),
+    user_away_timeout: String(opts.userAwayTimeout ?? ""),
+    preemptive_generation: String(opts.preemptiveGeneration ?? false),
+    use_tts_aligned_transcript: String(opts.useTtsAlignedTranscript ?? false)
+  };
+}
+class SessionHost {
+  transport;
+  session;
+  started = false;
+  eventsRegistered = false;
+  recvTask;
+  tasks = /* @__PURE__ */ new Set();
+  textInputCb;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  registerSession(session) {
+    this.session = session;
+    if (!this.eventsRegistered) {
+      this.eventsRegistered = true;
+      session.on(AgentSessionEventTypes.AgentStateChanged, this.onAgentStateChanged);
+      session.on(AgentSessionEventTypes.UserStateChanged, this.onUserStateChanged);
+      session.on(AgentSessionEventTypes.ConversationItemAdded, this.onConversationItemAdded);
+      session.on(AgentSessionEventTypes.UserInputTranscribed, this.onUserInputTranscribed);
+      session.on(AgentSessionEventTypes.FunctionToolsExecuted, this.onFunctionToolsExecuted);
+      session.on(AgentSessionEventTypes.MetricsCollected, this.onMetricsCollected);
+      session.on(AgentSessionEventTypes.OverlappingSpeech, this.onOverlappingSpeech);
+      session.on(AgentSessionEventTypes.Error, this.onHostError);
+    }
+  }
+  registerTextInput(textInputCb) {
+    this.textInputCb = textInputCb;
+  }
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.transport.start();
+    this.recvTask = Task.from(async () => this.recvLoop());
+  }
+  async close() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.session && this.eventsRegistered) {
+      this.eventsRegistered = false;
+      this.session.off(AgentSessionEventTypes.AgentStateChanged, this.onAgentStateChanged);
+      this.session.off(AgentSessionEventTypes.UserStateChanged, this.onUserStateChanged);
+      this.session.off(AgentSessionEventTypes.ConversationItemAdded, this.onConversationItemAdded);
+      this.session.off(AgentSessionEventTypes.UserInputTranscribed, this.onUserInputTranscribed);
+      this.session.off(AgentSessionEventTypes.FunctionToolsExecuted, this.onFunctionToolsExecuted);
+      this.session.off(AgentSessionEventTypes.MetricsCollected, this.onMetricsCollected);
+      this.session.off(AgentSessionEventTypes.OverlappingSpeech, this.onOverlappingSpeech);
+      this.session.off(AgentSessionEventTypes.Error, this.onHostError);
+    }
+    if (this.recvTask) {
+      this.recvTask.cancel();
+    }
+    await Promise.allSettled([...this.tasks].map((task) => task.cancelAndWait()));
+    this.tasks.clear();
+    await this.transport.close();
+  }
+  async recvLoop() {
+    try {
+      for await (const msg of this.transport) {
+        if (msg.message.case === "request") {
+          if (this.session) {
+            this.trackTask(
+              Task.from(async () => this.handleRequestSafe(msg.message.value))
+            );
+          }
+        }
+      }
+    } catch (e) {
+      if (this.started) {
+        log().warn({ error: e }, "error processing session message");
+      }
+    }
+  }
+  sendEvent(event) {
+    const msg = new pb.AgentSessionMessage({
+      message: { case: "event", value: event }
+    });
+    this.trackTask(Task.from(async () => this.transport.sendMessage(msg)));
+  }
+  emitEvent(event, createdAt) {
+    this.sendEvent(
+      new pb.AgentSessionEvent({
+        createdAt: createdAt ? msToTimestamp(createdAt) : nowTimestamp(),
+        event
+      })
+    );
+  }
+  onAgentStateChanged = (event) => {
+    this.emitEvent(
+      {
+        case: "agentStateChanged",
+        value: new pb.AgentSessionEvent_AgentStateChanged({
+          oldState: AGENT_STATE_MAP[event.oldState],
+          newState: AGENT_STATE_MAP[event.newState]
+        })
+      },
+      event.createdAt
+    );
+  };
+  onUserStateChanged = (event) => {
+    this.emitEvent(
+      {
+        case: "userStateChanged",
+        value: new pb.AgentSessionEvent_UserStateChanged({
+          oldState: USER_STATE_MAP[event.oldState],
+          newState: USER_STATE_MAP[event.newState]
+        })
+      },
+      event.createdAt
+    );
+  };
+  onUserInputTranscribed = (event) => {
+    this.emitEvent(
+      {
+        case: "userInputTranscribed",
+        value: new pb.AgentSessionEvent_UserInputTranscribed({
+          transcript: event.transcript,
+          isFinal: event.isFinal
+        })
+      },
+      event.createdAt
+    );
+  };
+  onConversationItemAdded = (event) => {
+    this.emitEvent(
+      {
+        case: "conversationItemAdded",
+        value: new pb.AgentSessionEvent_ConversationItemAdded({
+          item: chatItemToProto(event.item)
+        })
+      },
+      event.createdAt
+    );
+  };
+  onFunctionToolsExecuted = (event) => {
+    const pbCalls = event.functionCalls.map(
+      (fc) => new pb.FunctionCall({ name: fc.name, arguments: fc.args, callId: fc.callId })
+    );
+    const pbOutputs = event.functionCallOutputs.filter((fco) => fco != null).map(
+      (fco) => new pb.FunctionCallOutput({
+        callId: fco.callId,
+        output: fco.output,
+        isError: fco.isError
+      })
+    );
+    this.emitEvent(
+      {
+        case: "functionToolsExecuted",
+        value: new pb.AgentSessionEvent_FunctionToolsExecuted({
+          functionCalls: pbCalls,
+          functionCallOutputs: pbOutputs
+        })
+      },
+      event.createdAt
+    );
+  };
+  onOverlappingSpeech = (event) => {
+    const value = new pb.AgentSessionEvent_OverlappingSpeech({
+      isInterruption: event.isInterruption,
+      detectionDelay: event.detectionDelayInS,
+      detectedAt: msToTimestamp(event.detectedAt)
+    });
+    if (event.overlapStartedAt != null) {
+      value.overlapStartedAt = msToTimestamp(event.overlapStartedAt);
+    }
+    this.emitEvent({ case: "overlappingSpeech", value });
+  };
+  onMetricsCollected = (event) => {
+    if (!this.session) return;
+    this.emitEvent(
+      {
+        case: "sessionUsageUpdated",
+        value: new pb.AgentSessionEvent_SessionUsageUpdated({
+          usage: sessionUsageToProto(this.session.usage)
+        })
+      },
+      event.createdAt
+    );
+  };
+  onHostError = (event) => {
+    this.emitEvent(
+      {
+        case: "error",
+        value: new pb.AgentSessionEvent_Error({
+          message: event.error ? String(event.error) : "Unknown error"
+        })
+      },
+      event.createdAt
+    );
+  };
+  async handleRequestSafe(req) {
+    try {
+      await this.handleRequest(req);
+    } catch (e) {
+      log().warn({ error: e, requestId: req.requestId }, "error handling session request");
+      try {
+        const resp = new pb.AgentSessionMessage({
+          message: {
+            case: "response",
+            value: new pb.SessionResponse({
+              requestId: req.requestId,
+              error: "internal error"
+            })
+          }
+        });
+        await this.transport.sendMessage(resp);
+      } catch (e2) {
+        log().debug({ error: e2 }, "failed to send error response");
+      }
+    }
+  }
+  async handleRequest(req) {
+    if (!this.session) return;
+    switch (req.request.case) {
+      case "ping":
+        return this.sendResponse(req.requestId, {
+          case: "pong",
+          value: new pb.SessionResponse_Pong()
+        });
+      case "getChatHistory":
+        return this.handleGetChatHistory(req.requestId);
+      case "getAgentInfo":
+        return this.handleGetAgentInfo(req.requestId);
+      case "runInput":
+        return this.handleRunInput(req.requestId, req.request.value);
+      case "getSessionState":
+        return this.handleGetSessionState(req.requestId);
+      case "getRtcStats":
+        return this.sendResponse(req.requestId, {
+          case: "getRtcStats",
+          value: new pb.SessionResponse_GetRTCStatsResponse({
+            publisherStats: [],
+            subscriberStats: []
+          })
+        });
+      case "getSessionUsage":
+        return this.handleGetSessionUsage(req.requestId);
+    }
+  }
+  async handleGetChatHistory(requestId) {
+    const items = this.session.history.items.map(chatItemToProto);
+    return this.sendResponse(requestId, {
+      case: "getChatHistory",
+      value: new pb.SessionResponse_GetChatHistoryResponse({ items })
+    });
+  }
+  async handleGetAgentInfo(requestId) {
+    const agent = this.session.currentAgent;
+    return this.sendResponse(requestId, {
+      case: "getAgentInfo",
+      value: new pb.SessionResponse_GetAgentInfoResponse({
+        id: agent.id,
+        instructions: agent.instructions,
+        tools: toolNames(agent.toolCtx),
+        chatCtx: agent.chatCtx.items.map(chatItemToProto)
+      })
+    });
+  }
+  async handleRunInput(requestId, input) {
+    const text = input.text;
+    let items = [];
+    let error;
+    if (text) {
+      if (this.textInputCb) {
+        const cbResult = this.textInputCb(this.session, { text });
+        if (cbResult instanceof Promise) {
+          await cbResult;
+        }
+      } else {
+        try {
+          await this.session.interrupt({ force: true }).await;
+        } catch {
+        }
+        const result = this.session.run({ userInput: text });
+        try {
+          await result.wait();
+        } catch (e) {
+          error = e instanceof Error ? e.message : String(e);
+        }
+        items = result.events.map((ev) => chatItemToProto(ev.item));
+      }
+    }
+    return this.sendResponse(
+      requestId,
+      {
+        case: "runInput",
+        value: new pb.SessionResponse_RunInputResponse({ items })
+      },
+      error
+    );
+  }
+  async handleGetSessionState(requestId) {
+    const agent = this.session.currentAgent;
+    const startedAt = this.session._startedAt ?? Date.now();
+    return this.sendResponse(requestId, {
+      case: "getSessionState",
+      value: new pb.SessionResponse_GetSessionStateResponse({
+        agentState: AGENT_STATE_MAP[this.session.agentState],
+        userState: USER_STATE_MAP[this.session.userState],
+        agentId: agent.id,
+        options: protoSerializeOptions({
+          turnHandling: this.session.sessionOptions.turnHandling,
+          maxToolSteps: this.session.sessionOptions.maxToolSteps,
+          userAwayTimeout: this.session.sessionOptions.userAwayTimeout,
+          preemptiveGeneration: this.session.sessionOptions.preemptiveGeneration,
+          useTtsAlignedTranscript: this.session.sessionOptions.useTtsAlignedTranscript
+        }),
+        createdAt: msToTimestamp(startedAt)
+      })
+    });
+  }
+  async handleGetSessionUsage(requestId) {
+    return this.sendResponse(requestId, {
+      case: "getSessionUsage",
+      value: new pb.SessionResponse_GetSessionUsageResponse({
+        usage: sessionUsageToProto(this.session.usage),
+        createdAt: nowTimestamp()
+      })
+    });
+  }
+  async sendResponse(requestId, response, error) {
+    await this.transport.sendMessage(
+      new pb.AgentSessionMessage({
+        message: {
+          case: "response",
+          value: new pb.SessionResponse({ requestId, response, error })
+        }
+      })
+    );
+  }
+  trackTask(task) {
+    this.tasks.add(task);
+    task.addDoneCallback(() => {
+      this.tasks.delete(task);
+    });
+  }
+}
+class RemoteSession extends EventEmitter {
+  transport;
+  started = false;
+  tasks = /* @__PURE__ */ new Set();
+  pendingRequests = /* @__PURE__ */ new Map();
+  recvTask;
+  _logger = log();
+  constructor(transport) {
+    super();
+    this.transport = transport;
+  }
+  static fromRoom(room, roomIO) {
+    const transport = new RoomSessionTransport(room, roomIO);
+    return new RemoteSession(transport);
+  }
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.transport.start();
+    this.recvTask = Task.from(async () => this.recvLoop());
+  }
+  async close() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.recvTask) {
+      this.recvTask.cancel();
+    }
+    for (const pending of this.pendingRequests.values()) {
+      pending.reject(new Error("RemoteSession closed"));
+    }
+    this.pendingRequests.clear();
+    for (const task of this.tasks) {
+      task.cancel();
+    }
+    this.tasks.clear();
+    await this.transport.close();
+  }
+  async recvLoop() {
+    try {
+      for await (const msg of this.transport) {
+        switch (msg.message.case) {
+          case "event":
+            this.dispatchEvent(msg.message.value);
+            break;
+          case "response":
+            this.dispatchResponse(msg.message.value);
+            break;
+        }
+      }
+    } catch (e) {
+      if (this.started) {
+        this._logger.warn({ error: e }, "error in RemoteSession recv loop");
+      }
+    }
+  }
+  dispatchEvent(event) {
+    const ev = event.event;
+    switch (ev.case) {
+      case "agentStateChanged":
+        this.emit("agent_state_changed", ev.value);
+        break;
+      case "userStateChanged":
+        this.emit("user_state_changed", ev.value);
+        break;
+      case "userInputTranscribed":
+        this.emit("user_input_transcribed", ev.value);
+        break;
+      case "conversationItemAdded":
+        this.emit("conversation_item_added", ev.value);
+        break;
+      case "functionToolsExecuted":
+        this.emit("function_tools_executed", ev.value);
+        break;
+      case "overlappingSpeech":
+        this.emit("overlapping_speech", ev.value);
+        break;
+      case "sessionUsageUpdated":
+        this.emit("session_usage", ev.value);
+        break;
+      case "error":
+        this.emit("error", ev.value);
+        break;
+    }
+  }
+  dispatchResponse(response) {
+    const future = this.pendingRequests.get(response.requestId);
+    this.pendingRequests.delete(response.requestId);
+    if (future && !future.done) {
+      future.resolve(response);
+    }
+  }
+  async sendRequest(buildReq, timeout = 6e4) {
+    const requestId = shortuuid("req_");
+    const req = buildReq(requestId);
+    req.requestId = requestId;
+    const future = new Future();
+    this.pendingRequests.set(requestId, future);
+    const msg = new pb.AgentSessionMessage({
+      message: { case: "request", value: req }
+    });
+    await this.transport.sendMessage(msg);
+    const timer = setTimeout(() => {
+      if (!future.done) {
+        this.pendingRequests.delete(requestId);
+        future.reject(new Error("RemoteSession request timed out"));
+      }
+    }, timeout);
+    try {
+      const response = await future.await;
+      if (response.error) {
+        throw new Error(response.error);
+      }
+      return response;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async fetchSessionState() {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "getSessionState", value: new pb.SessionRequest_GetSessionState() }
+      })
+    );
+    if (resp.response.case !== "getSessionState") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  async fetchChatHistory() {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "getChatHistory", value: new pb.SessionRequest_GetChatHistory() }
+      })
+    );
+    if (resp.response.case !== "getChatHistory") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  async fetchAgentInfo() {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "getAgentInfo", value: new pb.SessionRequest_GetAgentInfo() }
+      })
+    );
+    if (resp.response.case !== "getAgentInfo") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  async sendMessage(text, responseTimeout = 6e4) {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "runInput", value: new pb.SessionRequest_RunInput({ text }) }
+      }),
+      responseTimeout
+    );
+    if (resp.response.case !== "runInput") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  async fetchRtcStats() {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "getRtcStats", value: new pb.SessionRequest_GetRTCStats() }
+      })
+    );
+    if (resp.response.case !== "getRtcStats") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  async fetchSessionUsage() {
+    const resp = await this.sendRequest(
+      (id) => new pb.SessionRequest({
+        requestId: id,
+        request: { case: "getSessionUsage", value: new pb.SessionRequest_GetSessionUsage() }
+      })
+    );
+    if (resp.response.case !== "getSessionUsage") {
+      throw new Error("unexpected response type");
+    }
+    return resp.response.value;
+  }
+  trackTask(task) {
+    this.tasks.add(task);
+    task.addDoneCallback(() => {
+      this.tasks.delete(task);
+    });
+  }
+}
+export {
+  RemoteSession,
+  RoomSessionTransport,
+  SessionHost,
+  SessionTransport
+};
+//# sourceMappingURL=remote_session.js.map