@shogo-ai/voice 1.9.13 → 2.4.1

package/dist/chunk-UW7VQ3S6.js

@@ -0,0 +1,148 @@
+// src/live/client.ts
+function encodeAudio(audio) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < audio.length; i += 32768) {
+      binary += String.fromCharCode(...audio.subarray(i, i + 32768));
+    }
+    return btoa(binary);
+  }
+  const BufferImpl = globalThis.Buffer;
+  if (BufferImpl) return BufferImpl.from(audio).toString("base64");
+  throw new Error("Base64 encoding is unavailable in this runtime");
+}
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+var LiveSession = class {
+  constructor(socket, initialSession) {
+    this.socket = socket;
+    this.initialSession = initialSession;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.latestUsageSeconds = 0;
+    this.startedPromise = new Promise((resolve, reject) => {
+      this.resolveStarted = resolve;
+      this.rejectStarted = reject;
+    });
+    this.started = this.startedPromise;
+    this.closedPromise = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+    socket.addEventListener("message", (message) => {
+      const raw = typeof message.data === "string" ? message.data : "";
+      if (!raw) return;
+      let event;
+      try {
+        event = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (event.type === "session.started") this.resolveStarted(event);
+      if (event.type === "session.usage.updated") {
+        const seconds = event.usage?.seconds;
+        if (typeof seconds === "number") this.latestUsageSeconds = seconds;
+      }
+      if (event.type === "session.closed") {
+        this.closed = true;
+        this.resolveClosed(event);
+      }
+      if (event.type === "error" && !this.closed) {
+        const messageText = String(event.error?.message || "Live session error");
+        this.rejectStarted(new Error(messageText));
+      }
+      for (const handler of this.handlers.get(String(event.type)) ?? []) handler(event);
+      for (const handler of this.handlers.get("*") ?? []) handler(event);
+    });
+    socket.addEventListener("close", () => {
+      if (!this.closed) this.resolveClosed();
+    });
+    socket.addEventListener("error", () => {
+      if (!this.closed) this.rejectStarted(new Error("Live session WebSocket error"));
+    });
+    socket.addEventListener("open", () => {
+      if (initialSession) this.send({ type: "session.start", session: initialSession });
+    });
+  }
+  on(eventType, handler) {
+    const handlers = this.handlers.get(eventType) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.handlers.set(eventType, handlers);
+    return () => handlers.delete(handler);
+  }
+  send(event) {
+    if (this.closed) throw new Error("Live session is closed");
+    this.socket.send(JSON.stringify(event));
+  }
+  appendAudio(audio) {
+    this.send({
+      type: "session.input_audio.append",
+      audio: typeof audio === "string" ? audio : encodeAudio(audio)
+    });
+  }
+  async close(timeoutMs = 15e3) {
+    if (this.closed) return;
+    if (this.socket.readyState === 1) this.send({ type: "session.close" });
+    const timeout = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    const result = await Promise.race([this.closedPromise, timeout]);
+    if (!this.closed) this.socket.close();
+    return result;
+  }
+};
+var ShogoLiveClient = class {
+  constructor(options) {
+    if (!!options.apiKey === !!options.runtimeToken) {
+      throw new Error("ShogoLiveClient requires exactly one of apiKey or runtimeToken.");
+    }
+    this.apiUrl = normalizeBaseUrl(options.apiUrl);
+    this.token = options.apiKey ?? options.runtimeToken;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.WebSocketImpl = options.WebSocket ?? globalThis.WebSocket;
+    if (typeof this.fetchImpl !== "function") throw new Error("fetch is unavailable");
+    if (typeof this.WebSocketImpl !== "function") throw new Error("WebSocket is unavailable");
+  }
+  httpUrl(path) {
+    return `${this.apiUrl}${path}`;
+  }
+  wsUrl(path) {
+    return this.httpUrl(path).replace(/^http/, "ws");
+  }
+  protocols() {
+    return ["shogo-live", `shogo-insecure-api-key.${this.token}`];
+  }
+  connect(session) {
+    const socket = new this.WebSocketImpl(this.wsUrl("/api/ai/v1/live/sessions"), this.protocols());
+    return new LiveSession(socket, session);
+  }
+  attach(sessionId) {
+    const socket = new this.WebSocketImpl(
+      this.wsUrl(`/api/ai/v1/live/sessions/${encodeURIComponent(sessionId)}/attach`),
+      this.protocols()
+    );
+    return new LiveSession(socket);
+  }
+  async createWebRtcSession(input) {
+    const response = await this.fetchImpl(this.httpUrl("/api/ai/v1/live/sessions"), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        session: input.session,
+        transport: { type: "webrtc", sdp: input.sdp }
+      })
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      throw new Error(body?.error?.message || `Live session creation failed (${response.status})`);
+    }
+    return body;
+  }
+};
+
+export {
+  LiveSession,
+  ShogoLiveClient
+};
+//# sourceMappingURL=chunk-UW7VQ3S6.js.map