@shogo-ai/voice 1.10.0 → 2.4.2

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

package/dist/chunk-ZAW6F3YT.js

@@ -0,0 +1,172 @@
+import {
+  stripAudioTags
+} from "./chunk-Q3TJAJ54.js";
+
+// src/shared/postJson.ts
+function createPostJson({
+  authHeaders,
+  fetchCredentials
+}) {
+  return async function postJson(path, body) {
+    return fetch(path, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders() },
+      credentials: fetchCredentials,
+      body: JSON.stringify(body)
+    });
+  };
+}
+
+// src/shared/memory.ts
+function createMemoryAddTool({
+  postJson,
+  memoryAddPath
+}) {
+  return async (params) => {
+    const fact = typeof params.fact === "string" ? params.fact : "";
+    if (!fact.trim()) return "Memory save failed: empty fact.";
+    try {
+      const res = await postJson(memoryAddPath, { fact });
+      if (!res.ok) return "Failed to save memory.";
+      return "Memory saved.";
+    } catch {
+      return "Memory save failed.";
+    }
+  };
+}
+function createMemoryContextInjector({
+  postJson,
+  memoryRetrievePath,
+  conversationRef,
+  enabled,
+  lastInjectedRef
+}) {
+  return async function inject(userText) {
+    if (!enabled) return;
+    try {
+      const res = await postJson(memoryRetrievePath, { query: userText, limit: 4 });
+      if (!res.ok) return;
+      const data = await res.json();
+      const results = data.results ?? [];
+      if (!results.length) return;
+      const lines = results.map((r) => `- ${r.chunk.trim().replace(/\s+/g, " ").slice(0, 200)}`).join("\n");
+      if (lines === lastInjectedRef.current) return;
+      lastInjectedRef.current = lines;
+      const payload = `Relevant memory about this user:
+${lines}`;
+      conversationRef.current?.sendContextualUpdate(payload);
+    } catch {
+    }
+  };
+}
+
+// src/shared/transcript.ts
+function createTranscriptDisconnectHandler({
+  isRestartingRef,
+  weStartedSessionRef,
+  transcriptRef,
+  onTranscript,
+  transcriptIngestPath,
+  postJson
+}) {
+  return function handleTranscriptOnDisconnect() {
+    if (isRestartingRef.current) {
+      return;
+    }
+    if (!weStartedSessionRef.current) {
+      transcriptRef.current = [];
+      return;
+    }
+    weStartedSessionRef.current = false;
+    const transcript = transcriptRef.current.join("\n");
+    transcriptRef.current = [];
+    if (onTranscript) {
+      void onTranscript(transcript);
+      return;
+    }
+    const trimmed = transcript.trim();
+    if (trimmed.length < 20) return;
+    void postJson(transcriptIngestPath, { transcript: trimmed }).catch(() => {
+    });
+  };
+}
+function appendTranscriptLine(msg, { transcriptRef, weStartedSessionRef }) {
+  if (!msg?.message || !msg?.source) return;
+  if (!weStartedSessionRef.current) return;
+  const speaker = msg.source === "user" ? "User" : "Agent";
+  const cleaned = msg.source === "user" ? msg.message : stripAudioTags(msg.message);
+  if (!cleaned) return;
+  transcriptRef.current.push(`${speaker}: ${cleaned}`);
+}
+
+// src/shared/sessionPayload.ts
+function sanitizeDynamicVariables(raw) {
+  if (raw == null) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (v == null) continue;
+    out[k] = typeof v === "string" ? v : String(v);
+  }
+  return out;
+}
+function buildSessionPayload(opts) {
+  const dynamicVariables = {
+    ...sanitizeDynamicVariables(opts.dynamicVariables),
+    character_name: opts.characterName,
+    user_context: opts.userContext
+  };
+  if (typeof opts.conversationId === "string" && opts.conversationId.length > 0) {
+    dynamicVariables.conversation_id = opts.conversationId;
+  }
+  const payload = {
+    signedUrl: opts.signedUrl,
+    dynamicVariables
+  };
+  const agentOverrides = {};
+  if (opts.suppressFirstMessage) {
+    agentOverrides.firstMessage = "";
+  }
+  if (typeof opts.agentPromptOverride === "string" && opts.agentPromptOverride.length > 0) {
+    agentOverrides.prompt = { prompt: opts.agentPromptOverride };
+  }
+  if (Object.keys(agentOverrides).length > 0) {
+    payload.overrides = { agent: agentOverrides };
+  }
+  return payload;
+}
+async function fetchSignedUrl({
+  path,
+  fetchCredentials,
+  authHeaders
+}) {
+  const res = await fetch(path, {
+    credentials: fetchCredentials,
+    headers: authHeaders()
+  });
+  if (!res.ok) throw new Error(`Signed URL request failed: ${res.status}`);
+  return await res.json();
+}
+function withProjectQuery(signedUrlPath, params) {
+  const tail = [];
+  if (typeof params.projectId === "string" && params.projectId.length > 0) {
+    tail.push(`projectId=${encodeURIComponent(params.projectId)}`);
+  }
+  if (typeof params.agentName === "string" && params.agentName.length > 0) {
+    tail.push(`agentName=${encodeURIComponent(params.agentName)}`);
+  }
+  if (tail.length === 0) return signedUrlPath;
+  const sep = signedUrlPath.includes("?") ? "&" : "?";
+  return `${signedUrlPath}${sep}${tail.join("&")}`;
+}
+
+export {
+  createPostJson,
+  createMemoryAddTool,
+  createMemoryContextInjector,
+  createTranscriptDisconnectHandler,
+  appendTranscriptLine,
+  buildSessionPayload,
+  fetchSignedUrl,
+  withProjectQuery
+};
+//# sourceMappingURL=chunk-ZAW6F3YT.js.map