@absolutejs/meeting 0.0.1-beta.0

package/README.md

@@ -0,0 +1,55 @@
+# @absolutejs/meeting
+
+Meeting-bot core for AbsoluteJS. Join a call through a **source adapter**,
+transcribe it live with the [`@absolutejs/voice`](https://github.com/absolutejs/voice)
+scribe, and surface **diarized turns + participants** for analysis (deal
+coaching, summaries, action items, …).
+
+Platform-agnostic: the core only depends on the small `MeetingSource` contract,
+so each platform is a separate adapter under
+[`meeting-adapters`](https://github.com/absolutejs/meeting-adapters) (mirrors
+`voice-adapters`):
+
+- `@absolutejs/meeting-recall` — Recall.ai (Meet / Zoom / Teams)
+- `@absolutejs/meeting-discord` — native `@discordjs/voice` receive
+
+## Usage
+
+```ts
+import { createMeeting } from "@absolutejs/meeting";
+import { deepgram } from "@absolutejs/voice-deepgram";
+import { recall } from "@absolutejs/meeting-recall";
+
+const meeting = await createMeeting({
+  source: recall({ apiKey: process.env.RECALL_API_KEY!, meetingUrl }),
+  stt: deepgram({ apiKey: process.env.DEEPGRAM_API_KEY!, diarize: true }),
+  sessionId: "deal-123",
+});
+
+meeting.on("turn", ({ turn }) => {
+  // { speaker, text, participant? } — stream to your analyzer / UI
+});
+meeting.on("end", ({ transcript }) => {
+  // full diarized transcript — run your deal-call analysis
+});
+
+await meeting.start(); // bot joins the call
+// ... later: await meeting.stop()
+```
+
+### Testing without a platform
+
+`createBufferMeetingSource` streams an in-memory PCM buffer in real time — the
+reference `MeetingSource` implementation and a test harness.
+
+## API
+
+- `createMeeting(options)` → `MeetingSession` (`on`, `start`, `stop`,
+  `getTranscript`, `getParticipants`).
+- `createBufferMeetingSource(options)` → `MeetingSource`.
+- Types: `MeetingSource`, `MeetingSourceEventMap`, `MeetingParticipant`,
+  `MeetingSession`, `MeetingTurn`, `CreateMeetingOptions`.
+
+## License
+
+CC BY-NC 4.0

package/dist/bufferSource.d.ts

@@ -0,0 +1,17 @@
+import type { AudioFormat } from "@absolutejs/voice";
+import type { MeetingParticipant, MeetingSource } from "./source";
+export type BufferMeetingSourceOptions = {
+    format: AudioFormat;
+    /** Raw audio matching `format` (e.g. pcm_s16le bytes). */
+    pcm: Uint8Array;
+    /** Chunk cadence in ms (how the buffer is paced out). Default 40. */
+    chunkMs?: number;
+    /** Optional roster to announce on start. */
+    participants?: MeetingParticipant[];
+};
+/**
+ * A meeting source backed by an in-memory PCM buffer, paced out in real time.
+ * Used to test the meeting core + voice scribe without a live platform, and as
+ * the reference implementation of `MeetingSource` for adapter authors.
+ */
+export declare const createBufferMeetingSource: (options: BufferMeetingSourceOptions) => MeetingSource;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createMeeting } from "./meeting";
+export type { MeetingSession, MeetingTurn, MeetingEventMap, CreateMeetingOptions, } from "./meeting";
+export { createBufferMeetingSource } from "./bufferSource";
+export type { BufferMeetingSourceOptions } from "./bufferSource";
+export type { MeetingSource, MeetingSourceEventMap, MeetingParticipant, } from "./source";

package/dist/index.js

@@ -0,0 +1,120 @@
+// @bun
+// src/meeting.ts
+import {
+  createVoiceScribe
+} from "@absolutejs/voice";
+var createMeeting = async (options) => {
+  const scribe = await createVoiceScribe({
+    format: options.source.format,
+    languageStrategy: options.languageStrategy,
+    lexicon: options.lexicon,
+    phraseHints: options.phraseHints,
+    sessionId: options.sessionId,
+    stt: options.stt
+  });
+  const participants = new Map;
+  let lastSpeaker;
+  const listeners = {
+    end: new Set,
+    error: new Set,
+    participant: new Set,
+    turn: new Set
+  };
+  const emit = (event, payload) => {
+    for (const handler of listeners[event])
+      handler(payload);
+  };
+  const resolveParticipant = (turn) => participants.get(turn.speaker) ?? (lastSpeaker ? participants.get(lastSpeaker) : undefined);
+  scribe.on("turn", ({ turn }) => {
+    emit("turn", { turn: { ...turn, participant: resolveParticipant(turn) } });
+  });
+  scribe.on("error", (event) => emit("error", { error: event.error }));
+  let ended = false;
+  const unsubscribe = [];
+  const finalize = async (reason) => {
+    if (ended)
+      return;
+    ended = true;
+    for (const off of unsubscribe)
+      off();
+    await scribe.close(reason);
+    const transcript = scribe.getTranscript().map((turn) => ({
+      ...turn,
+      participant: resolveParticipant(turn)
+    }));
+    emit("end", { reason, transcript });
+  };
+  unsubscribe.push(options.source.on("audio", ({ chunk, participant }) => {
+    if (participant)
+      lastSpeaker = participant;
+    scribe.send(chunk);
+  }), options.source.on("participant", ({ participant }) => {
+    participants.set(participant.id, participant);
+    emit("participant", { participant });
+  }), options.source.on("end", ({ reason }) => void finalize(reason)), options.source.on("error", ({ error }) => emit("error", { error })));
+  return {
+    getParticipants: () => [...participants.values()],
+    getTranscript: () => scribe.getTranscript().map((turn) => ({
+      ...turn,
+      participant: resolveParticipant(turn)
+    })),
+    on: (event, handler) => {
+      listeners[event].add(handler);
+      return () => {
+        listeners[event].delete(handler);
+      };
+    },
+    start: () => options.source.start(),
+    stop: async (reason) => {
+      await options.source.stop(reason);
+      await finalize(reason);
+    }
+  };
+};
+// src/bufferSource.ts
+var bytesPerSample = (format) => (format.encoding === "pcm_s16le" ? 2 : 1) * format.channels;
+var createBufferMeetingSource = (options) => {
+  const chunkMs = options.chunkMs ?? 40;
+  const listeners = {
+    audio: new Set,
+    end: new Set,
+    error: new Set,
+    participant: new Set
+  };
+  const emit = (event, payload) => {
+    for (const handler of listeners[event])
+      handler(payload);
+  };
+  let stopped = false;
+  return {
+    format: options.format,
+    on: (event, handler) => {
+      listeners[event].add(handler);
+      return () => {
+        listeners[event].delete(handler);
+      };
+    },
+    start: async () => {
+      for (const participant of options.participants ?? []) {
+        emit("participant", { participant });
+      }
+      const chunkBytes = Math.max(2, Math.round(bytesPerSample(options.format) * options.format.sampleRateHz * chunkMs / 1000));
+      (async () => {
+        for (let off = 0;off < options.pcm.length && !stopped; off += chunkBytes) {
+          emit("audio", { chunk: options.pcm.subarray(off, off + chunkBytes) });
+          await new Promise((resolve) => setTimeout(resolve, chunkMs));
+        }
+        if (!stopped)
+          emit("end", { reason: "buffer-complete" });
+      })();
+    },
+    stop: async (reason) => {
+      stopped = true;
+      emit("end", { reason: reason ?? "stopped" });
+    }
+  };
+};
+export {
+  createMeeting,
+  createBufferMeetingSource
+};

package/dist/meeting.d.ts

@@ -0,0 +1,45 @@
+import { type STTAdapter, type VoiceLanguageStrategy, type VoiceLexiconEntry, type VoicePhraseHint, type VoiceScribeTurn } from "@absolutejs/voice";
+import type { MeetingParticipant, MeetingSource } from "./source";
+export type MeetingTurn = VoiceScribeTurn & {
+    /** Resolved participant for this turn, when the source identified speakers. */
+    participant?: MeetingParticipant;
+};
+export type MeetingEventMap = {
+    turn: {
+        turn: MeetingTurn;
+    };
+    participant: {
+        participant: MeetingParticipant;
+    };
+    end: {
+        reason?: string;
+        transcript: MeetingTurn[];
+    };
+    error: {
+        error: Error;
+    };
+};
+export type MeetingSession = {
+    on: <K extends keyof MeetingEventMap>(event: K, handler: (payload: MeetingEventMap[K]) => void | Promise<void>) => () => void;
+    /** Join the call and start transcribing. */
+    start: () => Promise<void>;
+    /** Leave the call, finalize, and emit `end` with the full transcript. */
+    stop: (reason?: string) => Promise<void>;
+    getTranscript: () => MeetingTurn[];
+    getParticipants: () => MeetingParticipant[];
+};
+export type CreateMeetingOptions = {
+    source: MeetingSource;
+    stt: STTAdapter;
+    sessionId: string;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
+    phraseHints?: VoicePhraseHint[];
+};
+/**
+ * Wire a meeting source (any platform) to the voice scribe: audio flows
+ * source → scribe → diarized turns; the participant roster from the source is
+ * tracked alongside. Platform-agnostic — the Recall / Discord / onSpark
+ * adapters all satisfy `MeetingSource`, so this core never changes per platform.
+ */
+export declare const createMeeting: (options: CreateMeetingOptions) => Promise<MeetingSession>;

package/dist/source.d.ts

@@ -0,0 +1,44 @@
+import type { AudioChunk, AudioFormat } from "@absolutejs/voice";
+/** A participant in the call, as reported by the source platform. */
+export type MeetingParticipant = {
+    id: string;
+    name?: string;
+    /** Platform of origin, e.g. "recall", "discord", "onspark". */
+    platform?: string;
+    metadata?: Record<string, unknown>;
+};
+export type MeetingSourceEventMap = {
+    /** A chunk of call audio (in `format`). `participant` is set when the source
+     *  knows who is speaking for this chunk (per-user streams); otherwise omit it
+     *  and rely on the scribe's diarization. */
+    audio: {
+        chunk: AudioChunk;
+        participant?: string;
+    };
+    /** Roster update — someone joined / was identified. */
+    participant: {
+        participant: MeetingParticipant;
+    };
+    /** The call ended (everyone left, host stopped, etc.). */
+    end: {
+        reason?: string;
+    };
+    error: {
+        error: Error;
+    };
+};
+/**
+ * A meeting "source" — the thing that gets audio out of a call. Implemented by
+ * the platform adapters (`@absolutejs/meeting-recall`, `@absolutejs/meeting-
+ * discord`, an onSpark browser source, …). The core only depends on this
+ * contract, so a new platform is just a new adapter.
+ */
+export type MeetingSource = {
+    /** Audio format this source emits — fed straight into the scribe's STT. */
+    readonly format: AudioFormat;
+    on: <K extends keyof MeetingSourceEventMap>(event: K, handler: (payload: MeetingSourceEventMap[K]) => void | Promise<void>) => () => void;
+    /** Join the call / begin streaming audio. */
+    start: () => Promise<void>;
+    /** Leave the call / stop streaming. */
+    stop: (reason?: string) => Promise<void>;
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@absolutejs/meeting",
+	"version": "0.0.1-beta.0",
+	"description": "Meeting-bot core for AbsoluteJS — join a call (via a source adapter), transcribe it live with the voice scribe, and surface diarized turns + participants for analysis",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/absolutejs/meeting.git"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"license": "CC BY-NC 4.0",
+	"author": "Alex Kahn",
+	"scripts": {
+		"build": "rm -rf dist && bun build ./src/index.ts --outdir dist --target bun --external @absolutejs/voice && tsc --emitDeclarationOnly --project tsconfig.json",
+		"format": "prettier --write \"./**/*.{js,ts,json,md}\"",
+		"release": "bun run format && bun run build && bun publish",
+		"test": "bun test",
+		"typecheck": "bun run tsc --noEmit"
+	},
+	"dependencies": {
+		"@absolutejs/voice": "0.0.22-beta.550"
+	},
+	"devDependencies": {
+		"@types/bun": "1.3.9",
+		"typescript": "^5.9.3"
+	}
+}