@absolutejs/voice 0.0.1

package/dist/svelte/index.js

@@ -0,0 +1,456 @@
+// @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/client/actions.ts
+var serverMessageToAction = (message) => {
+  switch (message.type) {
+    case "assistant":
+      return {
+        text: message.text,
+        type: "assistant"
+      };
+    case "complete":
+      return {
+        sessionId: message.sessionId,
+        type: "complete"
+      };
+    case "error":
+      return {
+        message: message.message,
+        type: "error"
+      };
+    case "final":
+      return {
+        transcript: message.transcript,
+        type: "final"
+      };
+    case "partial":
+      return {
+        transcript: message.transcript,
+        type: "partial"
+      };
+    case "session":
+      return {
+        sessionId: message.sessionId,
+        status: message.status,
+        type: "session"
+      };
+    case "turn":
+      return {
+        turn: message.turn,
+        type: "turn"
+      };
+    default:
+      return null;
+  }
+};
+
+// src/client/connection.ts
+var WS_OPEN = 1;
+var WS_CLOSED = 3;
+var WS_NORMAL_CLOSURE = 1000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_PING_INTERVAL = 30000;
+var RECONNECT_DELAY_MS = 500;
+var noop = () => {};
+var noopUnsubscribe = () => noop;
+var NOOP_CONNECTION = {
+  close: noop,
+  endTurn: noop,
+  getReadyState: () => WS_CLOSED,
+  getSessionId: () => "",
+  send: noop,
+  sendAudio: noop,
+  subscribe: noopUnsubscribe
+};
+var createSessionId = () => crypto.randomUUID();
+var buildWsUrl = (path, sessionId) => {
+  const { hostname, port, protocol } = window.location;
+  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+  const portSuffix = port ? `:${port}` : "";
+  const url = new URL(`${wsProtocol}//${hostname}${portSuffix}${path}`);
+  url.searchParams.set("sessionId", sessionId);
+  return url.toString();
+};
+var isVoiceServerMessage = (value) => {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  switch (value.type) {
+    case "assistant":
+    case "complete":
+    case "error":
+    case "final":
+    case "partial":
+    case "pong":
+    case "session":
+    case "turn":
+      return true;
+    default:
+      return false;
+  }
+};
+var parseServerMessage = (event) => {
+  if (typeof event.data !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(event.data);
+    return isVoiceServerMessage(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var createVoiceConnection = (path, options = {}) => {
+  if (typeof window === "undefined") {
+    return NOOP_CONNECTION;
+  }
+  const listeners = new Set;
+  const shouldReconnect = options.reconnect !== false;
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const state = {
+    isConnected: false,
+    pendingMessages: [],
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    sessionId: options.sessionId ?? createSessionId(),
+    ws: null
+  };
+  const clearTimers = () => {
+    if (state.pingInterval) {
+      clearInterval(state.pingInterval);
+      state.pingInterval = null;
+    }
+    if (state.reconnectTimeout) {
+      clearTimeout(state.reconnectTimeout);
+      state.reconnectTimeout = null;
+    }
+  };
+  const flushPendingMessages = () => {
+    if (state.ws?.readyState !== WS_OPEN) {
+      return;
+    }
+    while (state.pendingMessages.length > 0) {
+      const next = state.pendingMessages.shift();
+      if (next !== undefined) {
+        state.ws.send(next);
+      }
+    }
+  };
+  const scheduleReconnect = () => {
+    state.reconnectAttempts += 1;
+    state.reconnectTimeout = setTimeout(() => {
+      if (state.reconnectAttempts > maxReconnectAttempts) {
+        return;
+      }
+      connect();
+    }, RECONNECT_DELAY_MS);
+  };
+  const connect = () => {
+    const ws = new WebSocket(buildWsUrl(path, state.sessionId));
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      state.isConnected = true;
+      state.reconnectAttempts = 0;
+      flushPendingMessages();
+      listeners.forEach((listener) => listener({
+        sessionId: state.sessionId,
+        status: "active",
+        type: "session"
+      }));
+      state.pingInterval = setInterval(() => {
+        if (ws.readyState === WS_OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    };
+    ws.onmessage = (event) => {
+      const parsed = parseServerMessage(event);
+      if (!parsed) {
+        return;
+      }
+      if (parsed.type === "session") {
+        state.sessionId = parsed.sessionId;
+      }
+      listeners.forEach((listener) => listener(parsed));
+    };
+    ws.onclose = (event) => {
+      state.isConnected = false;
+      clearTimers();
+      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
+      if (reconnectable) {
+        scheduleReconnect();
+      }
+    };
+    state.ws = ws;
+  };
+  const sendSerialized = (value) => {
+    if (state.ws?.readyState === WS_OPEN) {
+      state.ws.send(value);
+      return;
+    }
+    state.pendingMessages.push(value);
+  };
+  const send = (message) => {
+    sendSerialized(JSON.stringify(message));
+  };
+  const sendAudio = (audio) => {
+    sendSerialized(audio);
+  };
+  const endTurn = () => {
+    send({ type: "end_turn" });
+  };
+  const close = () => {
+    clearTimers();
+    if (state.ws) {
+      state.ws.close(WS_NORMAL_CLOSURE);
+      state.ws = null;
+    }
+    state.isConnected = false;
+    listeners.clear();
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  connect();
+  return {
+    close,
+    endTurn,
+    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
+    getSessionId: () => state.sessionId,
+    send,
+    sendAudio,
+    subscribe
+  };
+};
+
+// src/client/store.ts
+var createInitialState = () => ({
+  assistantTexts: [],
+  error: null,
+  isConnected: false,
+  partial: "",
+  sessionId: null,
+  status: "idle",
+  turns: []
+});
+var createVoiceStreamStore = () => {
+  let state = createInitialState();
+  const subscribers = new Set;
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const dispatch = (action) => {
+    switch (action.type) {
+      case "assistant":
+        state = {
+          ...state,
+          assistantTexts: [...state.assistantTexts, action.text]
+        };
+        break;
+      case "complete":
+        state = {
+          ...state,
+          sessionId: action.sessionId,
+          status: "completed"
+        };
+        break;
+      case "connected":
+        state = {
+          ...state,
+          isConnected: true
+        };
+        break;
+      case "disconnected":
+        state = {
+          ...state,
+          isConnected: false
+        };
+        break;
+      case "error":
+        state = {
+          ...state,
+          error: action.message
+        };
+        break;
+      case "final":
+        state = {
+          ...state,
+          partial: "",
+          turns: state.turns.map((turn) => turn)
+        };
+        break;
+      case "partial":
+        state = {
+          ...state,
+          partial: action.transcript.text
+        };
+        break;
+      case "session":
+        state = {
+          ...state,
+          error: null,
+          sessionId: action.sessionId,
+          status: action.status
+        };
+        break;
+      case "turn":
+        state = {
+          ...state,
+          partial: "",
+          turns: [...state.turns, action.turn]
+        };
+        break;
+    }
+    notify();
+  };
+  return {
+    dispatch,
+    getServerSnapshot: () => state,
+    getSnapshot: () => state,
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/client/createVoiceStream.ts
+var createVoiceStream = (path, options = {}) => {
+  const connection = createVoiceConnection(path, options);
+  const store = createVoiceStreamStore();
+  const subscribers = new Set;
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const unsubscribeConnection = connection.subscribe((message) => {
+    const action = serverMessageToAction(message);
+    if (action) {
+      store.dispatch(action);
+      notify();
+    }
+  });
+  store.dispatch({ type: "connected" });
+  return {
+    close() {
+      unsubscribeConnection();
+      connection.close();
+      store.dispatch({ type: "disconnected" });
+      notify();
+    },
+    endTurn() {
+      connection.endTurn();
+    },
+    get error() {
+      return store.getSnapshot().error;
+    },
+    get isConnected() {
+      return store.getSnapshot().isConnected;
+    },
+    get partial() {
+      return store.getSnapshot().partial;
+    },
+    get sessionId() {
+      return connection.getSessionId();
+    },
+    get status() {
+      return store.getSnapshot().status;
+    },
+    get turns() {
+      return store.getSnapshot().turns;
+    },
+    get assistantTexts() {
+      return store.getSnapshot().assistantTexts;
+    },
+    sendAudio(audio) {
+      connection.sendAudio(audio);
+    },
+    subscribe(subscriber) {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/svelte/createVoiceStream.ts
+var createVoiceStream2 = (path, options = {}) => createVoiceStream(path, options);
+export {
+  createVoiceStream2 as createVoiceStream
+};

package/dist/voice/src/angular/index.d.ts

@@ -0,0 +1 @@
+export { VoiceStreamService } from './voice-stream.service';

package/dist/voice/src/angular/voice-stream.service.d.ts

@@ -0,0 +1,15 @@
+import type { VoiceConnectionOptions, VoiceTurnRecord } from '../types';
+export declare class VoiceStreamService {
+    connect<TResult = unknown>(path: string, options?: VoiceConnectionOptions): {
+        assistantTexts: import("@angular/core").Signal<string[]>;
+        close: () => void;
+        endTurn: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isConnected: import("@angular/core").Signal<boolean>;
+        partial: import("@angular/core").Signal<string>;
+        sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+        sessionId: import("@angular/core").Signal<string>;
+        status: import("@angular/core").Signal<"idle" | import("..").VoiceSessionStatus>;
+        turns: import("@angular/core").Signal<VoiceTurnRecord<TResult>[]>;
+    };
+}

package/dist/voice/src/client/actions.d.ts

@@ -0,0 +1,58 @@
+import type { VoiceServerMessage } from '../types';
+export declare const serverMessageToAction: <TResult = unknown>(message: VoiceServerMessage<TResult>) => {
+    text: string;
+    type: "assistant";
+    sessionId?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    sessionId: string;
+    type: "complete";
+    text?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    message: string;
+    type: "error";
+    text?: undefined;
+    sessionId?: undefined;
+    transcript?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    transcript: import("..").Transcript;
+    type: "final";
+    text?: undefined;
+    sessionId?: undefined;
+    message?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    transcript: import("..").Transcript;
+    type: "partial";
+    text?: undefined;
+    sessionId?: undefined;
+    message?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    sessionId: string;
+    status: import("..").VoiceSessionStatus;
+    type: "session";
+    text?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    turn?: undefined;
+} | {
+    turn: import("..").VoiceTurnRecord<TResult>;
+    type: "turn";
+    text?: undefined;
+    sessionId?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    status?: undefined;
+} | null;

package/dist/voice/src/client/connection.d.ts

@@ -0,0 +1,12 @@
+import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
+type VoiceConnectionHandle = {
+    close: () => void;
+    endTurn: () => void;
+    getReadyState: () => number;
+    getSessionId: () => string;
+    send: (message: VoiceClientMessage) => void;
+    sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    subscribe: (callback: (message: VoiceServerMessage) => void) => () => void;
+};
+export declare const createVoiceConnection: (path: string, options?: VoiceConnectionOptions) => VoiceConnectionHandle;
+export {};

package/dist/voice/src/client/createVoiceStream.d.ts

@@ -0,0 +1,14 @@
+import type { VoiceConnectionOptions } from '../types';
+export declare const createVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
+    close(): void;
+    endTurn(): void;
+    readonly error: string | null;
+    readonly isConnected: boolean;
+    readonly partial: string;
+    readonly sessionId: string;
+    readonly status: "idle" | import("..").VoiceSessionStatus;
+    readonly turns: import("..").VoiceTurnRecord<TResult>[];
+    readonly assistantTexts: string[];
+    sendAudio(audio: Uint8Array | ArrayBuffer): void;
+    subscribe(subscriber: () => void): () => void;
+};

package/dist/voice/src/client/index.d.ts

@@ -0,0 +1,3 @@
+export { createVoiceConnection } from './connection';
+export { createVoiceStream } from './createVoiceStream';
+export { createMicrophoneCapture } from './microphone';

package/dist/voice/src/client/microphone.d.ts

@@ -0,0 +1,11 @@
+type MicrophoneCaptureOptions = {
+    channelCount?: 1 | 2;
+    onAudio: (audio: Uint8Array) => void;
+    sampleRateHz?: number;
+};
+type MicrophoneCapture = {
+    start: () => Promise<void>;
+    stop: () => void;
+};
+export declare const createMicrophoneCapture: (options: MicrophoneCaptureOptions) => MicrophoneCapture;
+export {};

package/dist/voice/src/client/store.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceStreamState, VoiceStoreAction } from '../types';
+export declare const createVoiceStreamStore: <TResult = unknown>() => {
+    dispatch: (action: VoiceStoreAction<TResult>) => void;
+    getServerSnapshot: () => VoiceStreamState<TResult>;
+    getSnapshot: () => VoiceStreamState<TResult>;
+    subscribe: (subscriber: () => void) => () => void;
+};

package/dist/voice/src/index.d.ts

@@ -0,0 +1,5 @@
+export { voice } from './plugin';
+export { createVoiceMemoryStore } from './memoryStore';
+export { createVoiceSession } from './session';
+export { createId, createVoiceSessionRecord } from './store';
+export * from './types';

package/dist/voice/src/logger.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceLogger } from './types';
+export declare const createNoopLogger: () => Required<VoiceLogger>;
+export declare const resolveLogger: (logger?: VoiceLogger) => {
+    debug: (message: string, meta?: Record<string, unknown>) => void;
+    info: (message: string, meta?: Record<string, unknown>) => void;
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+    error: (message: string, meta?: Record<string, unknown>) => void;
+};

package/dist/voice/src/memoryStore.d.ts

@@ -0,0 +1,2 @@
+import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+export declare const createVoiceMemoryStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>() => VoiceSessionStore<TSession>;

package/dist/voice/src/plugin.d.ts

@@ -0,0 +1,40 @@
+import { Elysia } from 'elysia';
+import type { VoicePluginConfig, VoiceSessionRecord } from './types';
+export declare const voice: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(config: VoicePluginConfig<TContext, TSession, TResult>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/voice/src/react/index.d.ts

@@ -0,0 +1 @@
+export { useVoiceStream } from './useVoiceStream';

package/dist/voice/src/react/useVoiceStream.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceConnectionOptions } from '../types';
+export declare const useVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
+    close: () => void;
+    endTurn: () => void;
+    sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    assistantTexts: string[];
+    error: string | null;
+    isConnected: boolean;
+    partial: string;
+    sessionId: string;
+    status: "idle" | import("..").VoiceSessionStatus;
+    turns: import("..").VoiceTurnRecord<TResult>[];
+};

package/dist/voice/src/session.d.ts

@@ -0,0 +1,2 @@
+import type { CreateVoiceSessionOptions, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export declare const createVoiceSession: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: CreateVoiceSessionOptions<TContext, TSession, TResult>) => VoiceSessionHandle<TContext, TSession, TResult>;

package/dist/voice/src/store.d.ts

@@ -0,0 +1,6 @@
+import type { Transcript, VoiceSessionRecord, VoiceSessionSummary } from './types';
+export declare const createId: () => `${string}-${string}-${string}-${string}-${string}`;
+export declare const createTranscript: (text: string, input?: Partial<Transcript>) => Transcript;
+export declare const createVoiceSessionRecord: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(id: string) => TSession;
+export declare const resetVoiceSessionRecord: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(id: string, existing?: TSession) => TSession;
+export declare const toVoiceSessionSummary: (session: VoiceSessionRecord) => VoiceSessionSummary;