@onlive.ai/common-121 0.2.32

package/services/livekit.service.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// services/livekit.service.ts
+var livekit_service_exports = {};
+__export(livekit_service_exports, {
+  CHAT_TOPIC: () => CHAT_TOPIC,
+  LivekitService: () => LivekitService,
+  Room: () => Room,
+  TRANSCRIPTION_TOPIC: () => TRANSCRIPTION_TOPIC
+});
+module.exports = __toCommonJS(livekit_service_exports);
+var import_components_core = require("@livekit/components-core");
+var import_livekit_client = require("livekit-client");
+
+// services/request.provider.ts
+var request = async (input, init) => {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(
+      JSON.stringify({
+        status: response.status,
+        statusText: response.statusText,
+        ...errorData
+      })
+    );
+  }
+  return response && response.json();
+};
+
+// services/livekit.service.ts
+var Room = class extends import_livekit_client.Room {
+  constructor(options) {
+    super(options);
+    __publicField(this, "id");
+    __publicField(this, "groupId");
+    __publicField(this, "createdAt");
+    __publicField(this, "connectedAt");
+  }
+};
+var CHAT_TOPIC = "lk.chat";
+var TRANSCRIPTION_TOPIC = "lk.transcription";
+var LivekitService = class {
+  constructor(options) {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "apiUrl");
+    __publicField(this, "version");
+    __publicField(this, "organizationId");
+    __publicField(this, "channelTopic");
+    __publicField(this, "transcriptionTopic");
+    __publicField(this, "setupChat");
+    __publicField(this, "abortControllers");
+    __publicField(this, "authToken", null);
+    __publicField(this, "messagePersistence");
+    __publicField(this, "room");
+    __publicField(this, "processMessage", async (reader, participantInfo) => {
+      const id = reader?.info?.id;
+      const participant = participantInfo?.identity ? this.room.getParticipantByIdentity(participantInfo.identity) : void 0;
+      let message = "";
+      for await (const chunk of reader) {
+        message += chunk;
+        this.emitMessage({
+          id,
+          timestamp: Date.now(),
+          message,
+          from: participant
+        });
+      }
+      if (this.messagePersistence === "client") {
+        this.persistMessage({
+          roomId: this.room.id,
+          content: message,
+          externalId: reader?.info?.id,
+          identity: participant?.identity,
+          kind: participant?.kind
+        });
+      }
+    });
+    __publicField(this, "emitMessage", (message) => {
+      for (const cb of this.listeners) {
+        cb([message]);
+      }
+    });
+    if ("room" in options) {
+      this.room = options.room;
+    } else {
+      this.apiUrl = options.apiUrl;
+      this.room = this.instanceRoom();
+    }
+    this.organizationId = options.organizationId;
+    this.version = options.version;
+    this.channelTopic = options.channelTopic || CHAT_TOPIC;
+    this.transcriptionTopic = options.transcriptionTopic || TRANSCRIPTION_TOPIC;
+    this.messagePersistence = options.messagePersistence || "disabled";
+    this.abortControllers = {
+      register: new AbortController(),
+      createRoom: new AbortController(),
+      closeRoom: new AbortController(),
+      evaluateRoom: new AbortController(),
+      persistMessage: new AbortController(),
+      sendMessageReport: new AbortController(),
+      deleteMessageReport: new AbortController(),
+      updateMessageReactions: new AbortController()
+    };
+  }
+  initialize() {
+    if (this.version === "v1") {
+      this.room.registerTextStreamHandler(this.channelTopic, this.processMessage);
+      this.room.registerTextStreamHandler(this.transcriptionTopic, this.processMessage);
+    } else {
+      this.setupChat = (0, import_components_core.setupChat)(this.room);
+    }
+  }
+  async register(externalId, secret, name) {
+    const response = await request(`${this.apiUrl}/users/register`, {
+      method: "POST",
+      body: JSON.stringify({
+        externalId,
+        secret,
+        name
+      }),
+      headers: {
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.register.signal
+    });
+    this.authToken = response.token;
+    return response;
+  }
+  async joinRoom(roomId, timezone, language) {
+    const response = await request(`${this.apiUrl}/rooms/${roomId}/join`, {
+      method: "POST",
+      body: JSON.stringify({ timezone, language }),
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.createRoom.signal
+    });
+    this.room.connect(response.wsURL, response.token);
+    this.initialize();
+    return this.room;
+  }
+  instanceRoom() {
+    if (!this.room) {
+      this.room = new Room({
+        adaptiveStream: true,
+        dynacast: true
+      });
+    }
+    return this.room;
+  }
+  async createRoom(options) {
+    this.room = this.instanceRoom();
+    const response = await request(`${this.apiUrl}/rooms`, {
+      method: "POST",
+      body: JSON.stringify(options),
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.createRoom.signal
+    });
+    this.room.id = response.id;
+    this.room.groupId = response.groupId;
+    this.room.createdAt = response.createdAt;
+    this.room.connectedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.room.connect(response.wsURL, response.token);
+    this.initialize();
+    return this.room;
+  }
+  async evaluateRoom(options) {
+    return request(`${this.apiUrl}/rooms/${this.room.id}/evaluate`, {
+      method: "POST",
+      body: JSON.stringify({
+        rating: options.rating,
+        comment: options.comment
+      }),
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.evaluateRoom.signal
+    });
+  }
+  async closeRoom() {
+    return request(`${this.apiUrl}/rooms/${this.room.id}/close`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.closeRoom.signal
+    });
+  }
+  async disconnect() {
+    if (this.room) {
+      this.room.removeAllListeners();
+      await this.room.disconnect();
+      this.closeRoom();
+      this.room = null;
+    }
+  }
+  async sendMessage(message) {
+    if (this.version === "v1") {
+      const textStream = await this.room.localParticipant.sendText(message, {
+        topic: this.channelTopic
+      });
+      this.emitMessage({
+        id: textStream.id,
+        timestamp: Date.now(),
+        message,
+        from: this.room.localParticipant
+      });
+      if (this.messagePersistence === "client") {
+        this.persistMessage({
+          roomId: this.room.id,
+          content: message,
+          externalId: textStream.id,
+          identity: this.room.localParticipant?.identity,
+          kind: this.room.localParticipant?.kind
+        });
+      }
+    } else {
+      await this.setupChat.send(message);
+    }
+  }
+  async persistMessage(options) {
+    return request(`${this.apiUrl}/messages/create`, {
+      method: "POST",
+      body: JSON.stringify(options),
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "X-Onlive-Organization-Id": this.organizationId,
+        "Content-Type": "application/json"
+      },
+      signal: this.abortControllers.persistMessage.signal
+    });
+  }
+  async getMessages(options) {
+    const query = new URLSearchParams();
+    if (options.with) {
+      query.append("with", options.with.join(","));
+    }
+    const response = await request(
+      `${this.apiUrl}/messages/search${query.size ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(options),
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          "X-Onlive-Organization-Id": this.organizationId,
+          "Content-Type": "application/json"
+        },
+        signal: this.abortControllers.createRoom.signal
+      }
+    );
+    return response.items;
+  }
+  async sendMessageReport(options) {
+    try {
+      return request(`${this.apiUrl}/messages/${options.messageId}/report`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          "X-Onlive-Organization-Id": this.organizationId,
+          "Content-Type": "application/json"
+        },
+        signal: this.abortControllers.sendMessageReport.signal
+      });
+    } catch (error) {
+      console.error("Error sending message report:", error);
+    }
+  }
+  async deleteMessageReport(options) {
+    try {
+      return request(`${this.apiUrl}/messages/${options.messageId}/report`, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          "X-Onlive-Organization-Id": this.organizationId,
+          "Content-Type": "application/json"
+        },
+        signal: this.abortControllers.deleteMessageReport.signal
+      });
+    } catch (error) {
+      console.error("Error deleting message report:", error);
+    }
+  }
+  async updateMessageReactions(options) {
+    try {
+      return request(`${this.apiUrl}/messages/${options.messageId}/reactions`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          add: options.add || [],
+          remove: options.remove || []
+        }),
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          "X-Onlive-Organization-Id": this.organizationId,
+          "Content-Type": "application/json"
+        },
+        signal: this.abortControllers.updateMessageReactions.signal
+      });
+    } catch (error) {
+      console.error("Error updating message reactions:", error);
+    }
+  }
+  subscribeMessages(callback) {
+    if (this.version === "v1") {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    } else {
+      const subscription = this.setupChat.messageObservable.subscribe(
+        callback
+      );
+      return () => subscription.unsubscribe();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHAT_TOPIC,
+  LivekitService,
+  Room,
+  TRANSCRIPTION_TOPIC
+});

package/services/livekit.service.d.cts

@@ -0,0 +1,131 @@
+import { ReceivedChatMessage } from '@livekit/components-core';
+import { Participant, Room as Room$1, RoomOptions as RoomOptions$1 } from 'livekit-client';
+
+interface RoomOptions extends Partial<RoomOptions$1> {
+}
+declare class Room extends Room$1 {
+    id: string;
+    groupId: string;
+    createdAt: string;
+    connectedAt: string;
+    constructor(options: RoomOptions);
+}
+interface UserFrom extends Participant {
+    id: string;
+    role: "user" | "agent" | "assistant";
+}
+interface ApiMessage extends ReceivedChatMessage {
+    content: string;
+    createdAt: string;
+    from?: UserFrom;
+    media?: Array<{
+        name?: string;
+        url: string;
+        ext: string;
+        type?: string;
+    }>;
+    reports?: Array<{
+        id: string;
+        createdAt: string;
+    }>;
+}
+type CreateRoomOptions = {
+    language: string;
+    timezone: string;
+    affinity?: Record<string, unknown>;
+    disablePersistence?: boolean;
+};
+type GetMessagesOptions = {
+    roomId?: string;
+    affinity?: {
+        agentId?: string;
+        agentType?: string;
+    };
+    with?: string[];
+};
+type PersistMessageOptions = {
+    externalId?: string;
+    roomId: string;
+    content: string;
+    identity?: string;
+    kind?: number;
+};
+type EvaluateRoomOptions = {
+    rating: number;
+    comment?: string;
+};
+type MessageReportOptions = {
+    messageId: string;
+};
+type MessageReactionOptions = {
+    messageId: string;
+    add?: string[];
+    remove?: string[];
+};
+type RoomApiResponse = {
+    id: string;
+    groupId: string;
+    token: string;
+    wsURL: string;
+    createdAt: string;
+};
+type UserApiResponse = {
+    id: string;
+    externalId: string;
+    organizationId: string;
+    role: string;
+    token: string;
+};
+type MessagesApiResponse = {
+    items: ApiMessage[];
+    count: number;
+    limit: number;
+    offset: number;
+};
+declare const CHAT_TOPIC: "lk.chat";
+declare const TRANSCRIPTION_TOPIC: "lk.transcription";
+type MessageListener<M = ApiMessage> = (messages: M[]) => void;
+type ChatServiceOptions = {
+    version: "v0" | "v1";
+    organizationId: string;
+    channelTopic?: string;
+    transcriptionTopic?: string;
+    messagePersistence?: "disabled" | "server" | "client";
+} & ({
+    apiUrl: string;
+} | {
+    room: Room;
+});
+declare class LivekitService {
+    private listeners;
+    private apiUrl;
+    private version;
+    private organizationId;
+    private channelTopic;
+    private transcriptionTopic;
+    private setupChat;
+    private abortControllers;
+    private authToken;
+    private messagePersistence?;
+    room: Room;
+    constructor(options: ChatServiceOptions);
+    private initialize;
+    private processMessage;
+    private emitMessage;
+    register(externalId: string, secret: string, name?: string): Promise<UserApiResponse>;
+    joinRoom(roomId: string, timezone: string, language: string): Promise<Room>;
+    instanceRoom(): Room;
+    createRoom(options: CreateRoomOptions): Promise<Room>;
+    evaluateRoom(options: EvaluateRoomOptions): Promise<void>;
+    closeRoom(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: string): Promise<void>;
+    persistMessage(options: PersistMessageOptions): Promise<MessagesApiResponse>;
+    getMessages(options: GetMessagesOptions): Promise<ApiMessage[]>;
+    sendMessageReport(options: MessageReportOptions): Promise<void>;
+    deleteMessageReport(options: MessageReportOptions): Promise<void>;
+    updateMessageReactions(options: MessageReactionOptions): Promise<void>;
+    subscribeMessages<M extends ApiMessage = ApiMessage>(callback: MessageListener<M>): () => void;
+}
+
+export { type ApiMessage, CHAT_TOPIC, type CreateRoomOptions, type EvaluateRoomOptions, type GetMessagesOptions, LivekitService, type MessageReactionOptions, type MessageReportOptions, type MessagesApiResponse, type PersistMessageOptions, Room, type RoomApiResponse, type RoomOptions, TRANSCRIPTION_TOPIC, type UserApiResponse, type UserFrom };

package/services/livekit.service.d.ts

@@ -0,0 +1,131 @@
+import { ReceivedChatMessage } from '@livekit/components-core';
+import { Participant, Room as Room$1, RoomOptions as RoomOptions$1 } from 'livekit-client';
+
+interface RoomOptions extends Partial<RoomOptions$1> {
+}
+declare class Room extends Room$1 {
+    id: string;
+    groupId: string;
+    createdAt: string;
+    connectedAt: string;
+    constructor(options: RoomOptions);
+}
+interface UserFrom extends Participant {
+    id: string;
+    role: "user" | "agent" | "assistant";
+}
+interface ApiMessage extends ReceivedChatMessage {
+    content: string;
+    createdAt: string;
+    from?: UserFrom;
+    media?: Array<{
+        name?: string;
+        url: string;
+        ext: string;
+        type?: string;
+    }>;
+    reports?: Array<{
+        id: string;
+        createdAt: string;
+    }>;
+}
+type CreateRoomOptions = {
+    language: string;
+    timezone: string;
+    affinity?: Record<string, unknown>;
+    disablePersistence?: boolean;
+};
+type GetMessagesOptions = {
+    roomId?: string;
+    affinity?: {
+        agentId?: string;
+        agentType?: string;
+    };
+    with?: string[];
+};
+type PersistMessageOptions = {
+    externalId?: string;
+    roomId: string;
+    content: string;
+    identity?: string;
+    kind?: number;
+};
+type EvaluateRoomOptions = {
+    rating: number;
+    comment?: string;
+};
+type MessageReportOptions = {
+    messageId: string;
+};
+type MessageReactionOptions = {
+    messageId: string;
+    add?: string[];
+    remove?: string[];
+};
+type RoomApiResponse = {
+    id: string;
+    groupId: string;
+    token: string;
+    wsURL: string;
+    createdAt: string;
+};
+type UserApiResponse = {
+    id: string;
+    externalId: string;
+    organizationId: string;
+    role: string;
+    token: string;
+};
+type MessagesApiResponse = {
+    items: ApiMessage[];
+    count: number;
+    limit: number;
+    offset: number;
+};
+declare const CHAT_TOPIC: "lk.chat";
+declare const TRANSCRIPTION_TOPIC: "lk.transcription";
+type MessageListener<M = ApiMessage> = (messages: M[]) => void;
+type ChatServiceOptions = {
+    version: "v0" | "v1";
+    organizationId: string;
+    channelTopic?: string;
+    transcriptionTopic?: string;
+    messagePersistence?: "disabled" | "server" | "client";
+} & ({
+    apiUrl: string;
+} | {
+    room: Room;
+});
+declare class LivekitService {
+    private listeners;
+    private apiUrl;
+    private version;
+    private organizationId;
+    private channelTopic;
+    private transcriptionTopic;
+    private setupChat;
+    private abortControllers;
+    private authToken;
+    private messagePersistence?;
+    room: Room;
+    constructor(options: ChatServiceOptions);
+    private initialize;
+    private processMessage;
+    private emitMessage;
+    register(externalId: string, secret: string, name?: string): Promise<UserApiResponse>;
+    joinRoom(roomId: string, timezone: string, language: string): Promise<Room>;
+    instanceRoom(): Room;
+    createRoom(options: CreateRoomOptions): Promise<Room>;
+    evaluateRoom(options: EvaluateRoomOptions): Promise<void>;
+    closeRoom(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: string): Promise<void>;
+    persistMessage(options: PersistMessageOptions): Promise<MessagesApiResponse>;
+    getMessages(options: GetMessagesOptions): Promise<ApiMessage[]>;
+    sendMessageReport(options: MessageReportOptions): Promise<void>;
+    deleteMessageReport(options: MessageReportOptions): Promise<void>;
+    updateMessageReactions(options: MessageReactionOptions): Promise<void>;
+    subscribeMessages<M extends ApiMessage = ApiMessage>(callback: MessageListener<M>): () => void;
+}
+
+export { type ApiMessage, CHAT_TOPIC, type CreateRoomOptions, type EvaluateRoomOptions, type GetMessagesOptions, LivekitService, type MessageReactionOptions, type MessageReportOptions, type MessagesApiResponse, type PersistMessageOptions, Room, type RoomApiResponse, type RoomOptions, TRANSCRIPTION_TOPIC, type UserApiResponse, type UserFrom };