@absolutejs/voice 0.0.1

package/dist/index.js

@@ -0,0 +1,693 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/plugin.ts
+import { Elysia } from "elysia";
+
+// src/logger.ts
+var noop = () => {};
+var createNoopLogger = () => ({
+  debug: noop,
+  error: noop,
+  info: noop,
+  warn: noop
+});
+var resolveLogger = (logger) => ({
+  ...createNoopLogger(),
+  ...logger
+});
+
+// src/store.ts
+var createId = () => crypto.randomUUID();
+var createVoiceSessionRecord = (id) => ({
+  committedTurnIds: [],
+  createdAt: Date.now(),
+  currentTurn: {
+    finalText: "",
+    partialText: "",
+    transcripts: []
+  },
+  id,
+  reconnect: { attempts: 0 },
+  status: "active",
+  transcripts: [],
+  turns: []
+});
+var resetVoiceSessionRecord = (id, existing) => ({
+  ...createVoiceSessionRecord(id),
+  metadata: existing?.metadata
+});
+var toVoiceSessionSummary = (session) => ({
+  createdAt: session.createdAt,
+  id: session.id,
+  lastActivityAt: session.lastActivityAt,
+  status: session.status,
+  turnCount: session.turns.length
+});
+
+// src/turnDetection.ts
+var DEFAULT_SILENCE_MS = 700;
+var buildTurnText = (transcripts, partialText) => {
+  const finalText = transcripts.map((transcript) => transcript.text.trim()).filter(Boolean).join(" ").trim();
+  if (finalText) {
+    return finalText;
+  }
+  return partialText.trim();
+};
+
+// src/session.ts
+var DEFAULT_RECONNECT_TIMEOUT = 30000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var toError = (value) => value instanceof Error ? value : new Error(String(value));
+var createEmptyCurrentTurn = () => ({
+  finalText: "",
+  partialText: "",
+  transcripts: []
+});
+var cloneTranscript = (transcript) => ({ ...transcript });
+var setTurnResult = (session, turnId, input) => {
+  session.turns = session.turns.map((turn) => turn.id === turnId ? {
+    ...turn,
+    assistantText: input.assistantText ?? turn.assistantText,
+    result: input.result ?? turn.result
+  } : turn);
+};
+var createVoiceSession = (options) => {
+  const logger = resolveLogger(options.logger);
+  const reconnect = {
+    maxAttempts: options.reconnect.maxAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS,
+    strategy: options.reconnect.strategy ?? "resume-last-turn",
+    timeout: options.reconnect.timeout ?? DEFAULT_RECONNECT_TIMEOUT
+  };
+  const turnDetection = {
+    silenceMs: options.turnDetection.silenceMs ?? DEFAULT_SILENCE_MS
+  };
+  let socket = options.socket;
+  let sttSession = null;
+  let silenceTimer = null;
+  const clearSilenceTimer = () => {
+    if (!silenceTimer) {
+      return;
+    }
+    clearTimeout(silenceTimer);
+    silenceTimer = null;
+  };
+  const send = async (message) => {
+    try {
+      await Promise.resolve(socket.send(JSON.stringify(message)));
+    } catch (error) {
+      logger.warn("voice socket send failed", {
+        error: toError(error).message,
+        sessionId: options.id,
+        type: message.type
+      });
+    }
+  };
+  const readSession = async () => options.store.getOrCreate(options.id);
+  const writeSession = async (mutate) => {
+    const session = await options.store.getOrCreate(options.id);
+    mutate(session);
+    await options.store.set(options.id, session);
+    return session;
+  };
+  const closeAdapter = async (reason) => {
+    if (!sttSession) {
+      return;
+    }
+    const activeSession = sttSession;
+    sttSession = null;
+    try {
+      await activeSession.close(reason);
+    } catch (error) {
+      logger.warn("voice stt close failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    }
+  };
+  const scheduleSilenceCommit = () => {
+    clearSilenceTimer();
+    silenceTimer = setTimeout(() => {
+      api.commitTurn("silence");
+    }, turnDetection.silenceMs);
+  };
+  const handleError = async (event) => {
+    await send({
+      message: event.error.message,
+      recoverable: event.recoverable,
+      type: "error"
+    });
+    if (!event.recoverable) {
+      await api.fail(event.error);
+    }
+  };
+  const handleClose = async (event) => {
+    if (event.recoverable === false) {
+      await api.fail(new Error(event.reason ?? "Speech-to-text session closed"));
+    }
+  };
+  const handlePartial = async (transcript) => {
+    await writeSession((session) => {
+      session.currentTurn.lastAudioAt = Date.now();
+      session.currentTurn.partialText = transcript.text;
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "partial"
+    });
+    scheduleSilenceCommit();
+  };
+  const handleFinal = async (transcript) => {
+    await writeSession((session) => {
+      const alreadyPresent = session.currentTurn.transcripts.some((existing) => existing.id === transcript.id);
+      if (!alreadyPresent) {
+        session.currentTurn.transcripts = [
+          ...session.currentTurn.transcripts,
+          cloneTranscript(transcript)
+        ];
+        session.transcripts = [
+          ...session.transcripts,
+          cloneTranscript(transcript)
+        ];
+      }
+      session.currentTurn.finalText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText);
+      session.currentTurn.lastAudioAt = Date.now();
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "final"
+    });
+    scheduleSilenceCommit();
+  };
+  const ensureAdapter = async () => {
+    if (sttSession) {
+      return sttSession;
+    }
+    sttSession = await options.stt.open({
+      format: {
+        channels: 1,
+        container: "raw",
+        encoding: "pcm_s16le",
+        sampleRateHz: 16000
+      },
+      sessionId: options.id
+    });
+    sttSession.on("partial", ({ transcript }) => {
+      handlePartial(transcript);
+    });
+    sttSession.on("final", ({ transcript }) => {
+      handleFinal(transcript);
+    });
+    sttSession.on("endOfTurn", ({ reason }) => {
+      clearSilenceTimer();
+      api.commitTurn(reason);
+    });
+    sttSession.on("error", (event) => {
+      handleError(event);
+    });
+    sttSession.on("close", (event) => {
+      handleClose(event);
+    });
+    return sttSession;
+  };
+  const completeTurn = async (session, turn) => {
+    const output = await options.route.onTurn({
+      api,
+      context: options.context,
+      session,
+      turn
+    });
+    if (output?.assistantText) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          assistantText: output.assistantText
+        });
+      });
+      await send({
+        text: output.assistantText,
+        turnId: turn.id,
+        type: "assistant"
+      });
+    }
+    if (output?.result !== undefined) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          result: output.result
+        });
+      });
+    }
+    if (output?.complete) {
+      await api.complete(output.result);
+    }
+  };
+  const api = {
+    id: options.id,
+    close: async (reason) => {
+      clearSilenceTimer();
+      await closeAdapter(reason);
+      await Promise.resolve(socket.close(1000, reason));
+    },
+    commitTurn: async (reason = "manual") => {
+      clearSilenceTimer();
+      const session = await readSession();
+      if (session.status === "completed" || session.status === "failed") {
+        return;
+      }
+      const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText);
+      if (!text) {
+        return;
+      }
+      const turn = {
+        committedAt: Date.now(),
+        id: createId(),
+        text,
+        transcripts: session.currentTurn.transcripts.length > 0 ? session.currentTurn.transcripts.map(cloneTranscript) : [
+          {
+            id: createId(),
+            isFinal: false,
+            text
+          }
+        ]
+      };
+      const updatedSession = await writeSession((currentSession) => {
+        currentSession.committedTurnIds = [
+          ...currentSession.committedTurnIds,
+          turn.id
+        ];
+        currentSession.currentTurn = createEmptyCurrentTurn();
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "active";
+        currentSession.turns = [...currentSession.turns, turn];
+      });
+      logger.info("voice turn committed", {
+        reason,
+        sessionId: options.id,
+        turnId: turn.id
+      });
+      await send({
+        turn,
+        type: "turn"
+      });
+      await completeTurn(updatedSession, turn);
+    },
+    complete: async (result) => {
+      clearSilenceTimer();
+      const session = await writeSession((currentSession) => {
+        if (currentSession.status === "completed") {
+          return;
+        }
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "completed";
+        if (result !== undefined && currentSession.turns.length > 0) {
+          const lastTurn = currentSession.turns.at(-1);
+          if (lastTurn) {
+            setTurnResult(currentSession, lastTurn.id, {
+              result
+            });
+          }
+        }
+      });
+      await send({
+        sessionId: options.id,
+        type: "complete"
+      });
+      await closeAdapter("complete");
+      await options.route.onComplete({
+        api,
+        context: options.context,
+        session
+      });
+    },
+    connect: async (nextSocket) => {
+      socket = nextSocket;
+      const existingSession = await options.store.get(options.id);
+      let session = existingSession ?? createVoiceSessionRecord(options.id);
+      let shouldFireOnSession = !existingSession;
+      if (existingSession?.status === "reconnecting") {
+        const nextAttempts = existingSession.reconnect.attempts + 1;
+        const reconnectExpired = existingSession.reconnect.lastDisconnectAt !== undefined && Date.now() - existingSession.reconnect.lastDisconnectAt > reconnect.timeout;
+        const tooManyAttempts = nextAttempts > reconnect.maxAttempts;
+        if (reconnect.strategy === "fail" && (reconnectExpired || tooManyAttempts)) {
+          await api.fail(new Error("Voice session reconnect policy exhausted"));
+          return;
+        }
+        if (reconnect.strategy === "restart" && (reconnectExpired || tooManyAttempts)) {
+          session = resetVoiceSessionRecord(options.id, existingSession);
+          shouldFireOnSession = true;
+        } else {
+          session = {
+            ...existingSession,
+            reconnect: {
+              ...existingSession.reconnect,
+              attempts: nextAttempts
+            },
+            status: "active"
+          };
+        }
+      }
+      await options.store.set(options.id, session);
+      await send({
+        sessionId: options.id,
+        status: session.status,
+        type: "session"
+      });
+      if (shouldFireOnSession) {
+        await options.route.onSession?.({
+          api,
+          context: options.context,
+          session
+        });
+      }
+      if (session.status === "completed") {
+        await send({
+          sessionId: options.id,
+          type: "complete"
+        });
+        return;
+      }
+      await ensureAdapter();
+    },
+    disconnect: async (event) => {
+      clearSilenceTimer();
+      await closeAdapter(event?.reason);
+      if (reconnect.strategy === "fail") {
+        await api.fail(new Error(event?.reason ?? "Voice socket disconnected"));
+        return;
+      }
+      await writeSession((session) => {
+        if (session.status === "completed" || session.status === "failed") {
+          return;
+        }
+        session.lastActivityAt = Date.now();
+        session.reconnect.lastDisconnectAt = Date.now();
+        session.status = "reconnecting";
+      });
+    },
+    fail: async (error) => {
+      clearSilenceTimer();
+      const session = await writeSession((currentSession) => {
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "failed";
+      });
+      const resolvedError = toError(error);
+      await send({
+        message: resolvedError.message,
+        recoverable: false,
+        type: "error"
+      });
+      await closeAdapter("failed");
+      await options.route.onError?.({
+        api,
+        context: options.context,
+        error: resolvedError,
+        session,
+        sessionId: options.id
+      });
+    },
+    receiveAudio: async (audio) => {
+      const session = await readSession();
+      if (session.status === "completed" || session.status === "failed") {
+        return;
+      }
+      const adapter = await ensureAdapter();
+      await writeSession((currentSession) => {
+        currentSession.currentTurn.lastAudioAt = Date.now();
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "active";
+      });
+      await adapter.send(audio);
+    },
+    snapshot: async () => readSession()
+  };
+  return api;
+};
+
+// src/plugin.ts
+var isArrayBufferView = (value) => typeof value === "object" && value !== null && ArrayBuffer.isView(value);
+var isVoiceClientMessage = (value) => {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  switch (value.type) {
+    case "close":
+      return true;
+    case "end_turn":
+      return true;
+    case "ping":
+      return true;
+    case "start":
+      return !("sessionId" in value) || typeof value.sessionId === "string";
+    default:
+      return false;
+  }
+};
+var parseClientMessage = (raw) => {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return isVoiceClientMessage(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  if (isVoiceClientMessage(raw)) {
+    return raw;
+  }
+  return null;
+};
+var resolveSessionId = (runtime, ws) => {
+  const existing = runtime.socketSessions.get(ws);
+  if (existing) {
+    return existing;
+  }
+  const query = ws.data && typeof ws.data === "object" && "query" in ws.data ? ws.data.query : undefined;
+  const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : createId();
+  runtime.socketSessions.set(ws, providedSessionId);
+  return providedSessionId;
+};
+var toAudioChunk = (raw) => {
+  if (raw instanceof ArrayBuffer) {
+    return raw;
+  }
+  if (isArrayBufferView(raw)) {
+    return raw;
+  }
+  return null;
+};
+var createSocketAdapter = (ws) => ({
+  close: async (code, reason) => {
+    ws.close(code, reason);
+  },
+  send: async (data) => {
+    ws.send(data);
+  }
+});
+var voice = (config) => {
+  const runtime = {
+    activeSessions: new Map,
+    logger: resolveLogger(config.logger),
+    socketSessions: new WeakMap
+  };
+  return new Elysia({ name: "absolutejs-voice" }).ws(config.path, {
+    close: async (ws, code, reason) => {
+      const sessionId = runtime.socketSessions.get(ws);
+      if (!sessionId) {
+        return;
+      }
+      const session = runtime.activeSessions.get(sessionId);
+      runtime.activeSessions.delete(sessionId);
+      if (session) {
+        await session.disconnect({
+          code,
+          reason,
+          recoverable: true,
+          type: "close"
+        });
+      }
+    },
+    message: async (ws, raw) => {
+      const sessionId = resolveSessionId(runtime, ws);
+      const current = runtime.activeSessions.get(sessionId);
+      const message = parseClientMessage(raw);
+      if (message) {
+        if (message.type === "ping") {
+          ws.send(JSON.stringify({ type: "pong" }));
+        }
+        if (message.type === "end_turn" && current) {
+          await current.commitTurn("manual");
+        }
+        if (message.type === "close" && current) {
+          await current.close(message.reason);
+          runtime.activeSessions.delete(sessionId);
+        }
+        if (message.type === "start" && message.sessionId && message.sessionId !== sessionId) {
+          runtime.socketSessions.set(ws, message.sessionId);
+        }
+        return;
+      }
+      const audio = toAudioChunk(raw);
+      if (!audio) {
+        return;
+      }
+      const session = current ?? createVoiceSession({
+        context: ws.data,
+        id: sessionId,
+        logger: config.logger,
+        reconnect: {
+          maxAttempts: config.reconnect?.maxAttempts ?? 10,
+          strategy: config.reconnect?.strategy ?? "resume-last-turn",
+          timeout: config.reconnect?.timeout ?? 30000
+        },
+        route: {
+          onComplete: config.onComplete,
+          onError: config.onError,
+          onSession: config.onSession,
+          onTurn: config.onTurn
+        },
+        socket: createSocketAdapter(ws),
+        store: config.session,
+        stt: config.stt,
+        turnDetection: {
+          silenceMs: config.turnDetection?.silenceMs ?? 700
+        }
+      });
+      if (!current) {
+        runtime.activeSessions.set(sessionId, session);
+        await session.connect(createSocketAdapter(ws));
+      }
+      await session.receiveAudio(audio);
+    },
+    open: async (ws) => {
+      const sessionId = resolveSessionId(runtime, ws);
+      const existing = runtime.activeSessions.get(sessionId);
+      if (existing) {
+        await existing.close("superseded");
+        runtime.activeSessions.delete(sessionId);
+      }
+      const session = createVoiceSession({
+        context: ws.data,
+        id: sessionId,
+        logger: config.logger,
+        reconnect: {
+          maxAttempts: config.reconnect?.maxAttempts ?? 10,
+          strategy: config.reconnect?.strategy ?? "resume-last-turn",
+          timeout: config.reconnect?.timeout ?? 30000
+        },
+        route: {
+          onComplete: config.onComplete,
+          onError: config.onError,
+          onSession: config.onSession,
+          onTurn: config.onTurn
+        },
+        socket: createSocketAdapter(ws),
+        store: config.session,
+        stt: config.stt,
+        turnDetection: {
+          silenceMs: config.turnDetection?.silenceMs ?? 700
+        }
+      });
+      runtime.activeSessions.set(sessionId, session);
+      await session.connect(createSocketAdapter(ws));
+    }
+  });
+};
+// src/memoryStore.ts
+var createVoiceMemoryStore = () => {
+  const sessions = new Map;
+  const get = async (id) => sessions.get(id);
+  const getOrCreate = async (id) => {
+    let session = sessions.get(id);
+    if (!session) {
+      session = createVoiceSessionRecord(id);
+      sessions.set(id, session);
+    }
+    return session;
+  };
+  const set = async (id, value) => {
+    sessions.set(id, value);
+  };
+  const list = async () => Array.from(sessions.values()).map((session) => toVoiceSessionSummary(session)).sort((first, second) => (second.lastActivityAt ?? second.createdAt) - (first.lastActivityAt ?? first.createdAt));
+  const remove = async (id) => {
+    sessions.delete(id);
+  };
+  return { get, getOrCreate, list, remove, set };
+};
+export {
+  voice,
+  createVoiceSessionRecord,
+  createVoiceSession,
+  createVoiceMemoryStore,
+  createId
+};