@craftedxp/voice-js 0.4.2 → 0.6.0

package/dist/browser.mjs

@@ -1015,6 +1015,288 @@ async function createWebRtcCall(opts) {
   };
 }
 
+// src/room.ts
+import {
+  Room,
+  RoomEvent,
+  Track
+} from "livekit-client";
+
+// src/roomProtocol.ts
+var SYSTEM_TOPIC = "system";
+var TRANSCRIPT_TOPIC = "transcript";
+var decodeSystem = (bytes) => {
+  try {
+    const v = JSON.parse(new TextDecoder().decode(bytes));
+    if (v && typeof v.kind === "string") return v;
+    return null;
+  } catch {
+    return null;
+  }
+};
+var decodeTranscript = (bytes) => {
+  try {
+    const v = JSON.parse(new TextDecoder().decode(bytes));
+    if (v && v.kind === "partial") return v;
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+// src/room.ts
+var identityToPid = (identity) => identity.startsWith("guest:") ? identity.slice("guest:".length) : identity;
+var joinRoom = async (opts) => {
+  const exchangeUrl = `${opts.apiBase.replace(/\/+$/, "")}/v1/rooms/${encodeURIComponent(
+    opts.roomId
+  )}/join`;
+  const exchangeRes = await fetch(exchangeUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code: opts.joinCode, name: opts.name })
+  });
+  if (!exchangeRes.ok) {
+    const err = await exchangeRes.json().catch(() => ({}));
+    throw new Error(err.error?.code ?? `join_failed_${exchangeRes.status}`);
+  }
+  const exchange = await exchangeRes.json();
+  const handlers = /* @__PURE__ */ new Map();
+  const emit = (e, payload) => {
+    handlers.get(e)?.forEach((h) => {
+      try {
+        h(payload);
+      } catch {
+      }
+    });
+  };
+  const room = new Room({ adaptiveStream: true, dynacast: true });
+  room.on(
+    RoomEvent.ParticipantConnected,
+    (p) => emit("participant.joined", {
+      participantId: identityToPid(p.identity),
+      name: p.name ?? ""
+    })
+  );
+  room.on(
+    RoomEvent.ParticipantDisconnected,
+    (p) => emit("participant.left", {
+      participantId: identityToPid(p.identity),
+      name: p.name ?? ""
+    })
+  );
+  room.on(RoomEvent.Disconnected, () => emit("room.ended", void 0));
+  room.on(RoomEvent.DataReceived, (data, _participant, _kind, topic) => {
+    if (topic === SYSTEM_TOPIC) {
+      const m = decodeSystem(data);
+      if (m) emit("system.message", m);
+    } else if (topic === TRANSCRIPT_TOPIC) {
+      const m = decodeTranscript(data);
+      if (m) emit("transcript.partial", m);
+    }
+  });
+  const trackKind = (t) => t.kind === Track.Kind.Video ? "video" : "audio";
+  const trackSource = (s) => {
+    switch (s) {
+      case Track.Source.Camera:
+        return "camera";
+      case Track.Source.Microphone:
+        return "microphone";
+      case Track.Source.ScreenShare:
+        return "screen_share";
+      case Track.Source.ScreenShareAudio:
+        return "screen_share_audio";
+      default:
+        return "unknown";
+    }
+  };
+  room.on(
+    RoomEvent.TrackSubscribed,
+    (track, pub, participant) => emit("track.subscribed", {
+      participantId: identityToPid(participant.identity),
+      kind: trackKind(track),
+      source: trackSource(pub.source),
+      track
+    })
+  );
+  room.on(
+    RoomEvent.TrackUnsubscribed,
+    (track, pub, participant) => emit("track.unsubscribed", {
+      participantId: identityToPid(participant.identity),
+      kind: trackKind(track),
+      source: trackSource(pub.source),
+      track
+    })
+  );
+  room.on(
+    RoomEvent.ActiveSpeakersChanged,
+    (speakers) => emit(
+      "active.speakers",
+      speakers.map((p) => identityToPid(p.identity))
+    )
+  );
+  await room.connect(exchange.livekit.url, exchange.livekit.token);
+  return {
+    participantId: exchange.participantId,
+    get participants() {
+      return [...room.remoteParticipants.values()].map((p) => ({
+        participantId: identityToPid(p.identity),
+        name: p.name ?? ""
+      }));
+    },
+    on(event, handler) {
+      const set = handlers.get(event) ?? /* @__PURE__ */ new Set();
+      set.add(handler);
+      handlers.set(event, set);
+    },
+    publishMic: async () => {
+      await room.localParticipant.setMicrophoneEnabled(true);
+    },
+    publishCamera: async () => {
+      await room.localParticipant.setCameraEnabled(true);
+    },
+    setMicEnabled: async (on) => {
+      await room.localParticipant.setMicrophoneEnabled(on);
+    },
+    setCameraEnabled: async (on) => {
+      await room.localParticipant.setCameraEnabled(on);
+    },
+    isMicEnabled: () => room.localParticipant.isMicrophoneEnabled,
+    isCameraEnabled: () => room.localParticipant.isCameraEnabled,
+    getLocalCameraTrack: () => room.localParticipant.getTrackPublication(Track.Source.Camera)?.videoTrack ?? null,
+    getRemoteTracks: () => {
+      const out = [];
+      for (const p of room.remoteParticipants.values()) {
+        for (const pub of p.trackPublications.values()) {
+          const track = pub.track;
+          if (!track) continue;
+          out.push({
+            participantId: identityToPid(p.identity),
+            kind: trackKind(track),
+            source: trackSource(pub.source),
+            track
+          });
+        }
+      }
+      return out;
+    },
+    setScreenShareEnabled: async (on, opts2) => {
+      await room.localParticipant.setScreenShareEnabled(on, { audio: opts2?.audio ?? false });
+    },
+    isScreenShareEnabled: () => room.localParticipant.isScreenShareEnabled,
+    getLocalScreenTrack: () => room.localParticipant.getTrackPublication(Track.Source.ScreenShare)?.videoTrack ?? null,
+    leave: async () => {
+      await room.disconnect();
+    }
+  };
+};
+
+// src/textSession.ts
+async function startTextSession(opts) {
+  const f = opts.fetch ?? fetch;
+  const tokenQs = `?token=${encodeURIComponent(opts.token)}`;
+  const startUrl = `${opts.baseUrl}/v1/agents/${opts.agentId}/chat${tokenQs}`;
+  const startBody = opts.text ? JSON.stringify({ text: opts.text }) : "{}";
+  const res = await f(startUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+    body: startBody
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`startTextSession failed: ${res.status} ${text}`);
+  }
+  const iter = parseSse(res.body);
+  let chatId = "";
+  let callId = "";
+  const buffered = [];
+  const it = iter[Symbol.asyncIterator]();
+  while (true) {
+    const { value, done } = await it.next();
+    if (done) break;
+    if (value.type === "chat.started") {
+      chatId = value.chatId;
+      callId = value.callId;
+      break;
+    }
+    buffered.push(value);
+  }
+  return {
+    id: chatId,
+    callId,
+    greeting: replayThen(buffered, { [Symbol.asyncIterator]: () => it }),
+    async send(text) {
+      const r = await f(`${opts.baseUrl}/v1/chats/${chatId}/messages${tokenQs}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+        body: JSON.stringify({ text })
+      });
+      if (!r.ok || !r.body) {
+        const errText = await r.text().catch(() => "");
+        throw new Error(`send failed: ${r.status} ${errText}`);
+      }
+      return parseSse(r.body);
+    },
+    async end() {
+      await f(`${opts.baseUrl}/v1/calls/${callId}`, { method: "DELETE" });
+    }
+  };
+}
+async function* parseSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) return;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) >= 0) {
+      const chunk = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      let event = "message";
+      let data = "";
+      for (const line of chunk.split("\n")) {
+        if (line.startsWith(":")) continue;
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) data += line.slice(5).trim();
+      }
+      if (!data) continue;
+      try {
+        const parsed = JSON.parse(data);
+        yield { type: event, ...parsed };
+      } catch {
+      }
+    }
+  }
+}
+async function* replayThen(buffered, rest) {
+  for (const x of buffered) yield x;
+  for await (const x of rest) yield x;
+}
+
+// src/incomingCall.ts
+var parseIncomingCall = (raw) => {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("parseIncomingCall: payload must be an object");
+  }
+  const p = raw;
+  if (typeof p.token !== "string" || !p.token.startsWith("ct_")) {
+    throw new Error("parseIncomingCall: missing or invalid `token` (expected a ct_ string)");
+  }
+  if (typeof p.agentId !== "string" || p.agentId.length === 0) {
+    throw new Error("parseIncomingCall: missing `agentId`");
+  }
+  const transport = p.transport === "webrtc" ? "webrtc" : "ws";
+  const out = { token: p.token, agentId: p.agentId, transport };
+  if (transport === "webrtc" && typeof p.webrtcGatewayBase === "string") {
+    out.webrtcGatewayBase = p.webrtcGatewayBase;
+  }
+  if (typeof p.expiresAt === "number") out.expiresAt = p.expiresAt;
+  if (typeof p.agentName === "string") out.agentName = p.agentName;
+  if (typeof p.agentAvatarUrl === "string") out.agentAvatarUrl = p.agentAvatarUrl;
+  return out;
+};
+
 // src/browser.ts
 var browserWsFactory = (url) => new globalThis.WebSocket(url);
 var BrowserVoiceFactory = class {
@@ -1072,6 +1354,21 @@ var BrowserVoiceFactory = class {
       await client.start();
       return client;
     };
+    // Multi-party rooms (Phase 7 video).
+    //
+    // The guest's browser calls this with the roomId + joinCode it parsed
+    // out of the invite link. The SDK exchanges the code for a LiveKit
+    // JWT against `${apiBase}/v1/rooms/:roomId/join` (an AUTH-EXEMPT
+    // endpoint — the opaque code is the only credential), then connects
+    // to LiveKit and returns a typed event surface.
+    this.joinRoom = (opts) => joinRoom({ apiBase: this.config.apiBase, ...opts });
+    // Text-channel chat session (no microphone / audio).
+    // Mint a `ct_` token with `channel: 'text'` on your backend, then call
+    // this to open an SSE stream against the chat API.
+    this.startTextSession = (opts) => startTextSession({
+      ...opts,
+      baseUrl: this.config.apiBase
+    });
     this.config = config;
   }
 };
@@ -1085,6 +1382,9 @@ export {
   createAudioPlayback,
   createProtocolState,
   createReconnectingWebSocket,
-  handleServerMessage
+  handleServerMessage,
+  joinRoom,
+  parseIncomingCall,
+  startTextSession
 };
 //# sourceMappingURL=browser.mjs.map