@4players/odin-nodejs 0.7.0

package/odin.client.d.ts

@@ -0,0 +1,22 @@
+import {OdinRoom} from "./odin.room";
+
+/**
+ * The Odin client is the main entry point for the Odin SDK. It is used to create rooms. Create an instance with your
+ * access key and use it to create rooms.
+ */
+export declare class OdinClient {
+    /**
+     * Creates a new instance of a client with an access key.
+     * @param accessKey {string} The access key to use for this client. You can get one from https://developers.4players.io
+     * @param sampleRate {number} The sample rate of the audio stream (between 8000 and 48000)
+     * @param channelCount {number} The number of channels of the audio stream (1 or 2)
+     */
+    constructor(accessKey: string, sampleRate?: number, channelCount?: number);
+
+    /**
+     * Creates a new local room instance with the given ID and user ID. Use join to connect to that room.
+     * @param roomId {string} The ID of the room to create.
+     * @param userId {string} The ID of the user to create the room for.
+     */
+    createRoom(roomId: string, userId: string): OdinRoom;
+}

package/odin.media.d.ts

@@ -0,0 +1,33 @@
+import {OdinRoom} from "./odin.room";
+
+/**
+ * The OdinMedia class. Represents a local media stream added to the room - i.e. a microphone, another audio stream like files.
+ * Don't create OdinMedia instances directly, use `createAudioStream` from OdinRoom instead.
+ */
+export declare class OdinMedia {
+    /**
+     * Creates a new instance of a media object. Don't create OdinMedia directly, use `createAudioStream` from OdinRoom instead.
+     * @param room {OdinRoom} The room to add the media to.
+     * @param sampleRate {number} The sample rate of the audio stream (between 8000 and 48000)
+     * @param channelCount {number} The number of channels of the audio stream (1 or 2)
+     */
+    constructor(room: OdinRoom, sampleRate: number, channelCount: number);
+
+    /**
+     * Closes the local audio stream and removed the media from the room
+     */
+    close(): void;
+
+    /**
+     * Sends audio data to the room. The data must be in the format specified when creating the media as a 32-bit float array.
+     * Samples need to be between -1 and 1. Audio data needs to be sent in regular intervals, otherwise the audio will be sound
+     * interrupted. See the example for more details.
+     * @param data
+     */
+    sendAudioData(data: Float32Array): void;
+
+    /**
+     * Gets the ID of the media.
+     */
+    get id(): string;
+}

package/odin.room.d.ts

@@ -0,0 +1,473 @@
+import {OdinMedia} from "./odin.media";
+
+declare interface OdinEvents {
+    /**
+     * Fired when the local user connected to the room (successfully joined).
+     */
+    Joined: OdinJoinedEvent;
+
+    /**
+     * Fired when the local user disconnected from the room (left).
+     */
+    Left: OdinLeftEvent;
+
+    /**
+     * Fired when a remote peer joined the room. This event is fired for all existing peers in the room before the Joined event is fired.
+     */
+    PeerJoined: OdinPeerJoinedEvent;
+
+    /**
+     * Fired when a remote peer left the room.
+     */
+    PeerLeft: OdinPeerLeftEvent;
+
+    /**
+     * Fired when a remote peer sent a message to the room.
+     */
+    MessageReceived: OdinMessageReceivedEvent;
+
+    /**
+     * Fired when the user data of a remote peer changed.
+     */
+    PeerUserDataChanged: OdinPeerUserDataChangedEvent;
+
+    /**
+     * Fired when the user data of the room changed.
+     */
+    RoomUserDataChanged: OdinRoomUserDataChangedEvent;
+
+    /**
+     * Fired when the connection state of the room changed.
+     */
+    ConnectionStateChanged: OdinConnectionStateChangedEvent;
+
+    /**
+     * Fired when a media stream was added to a peer. This happens for example if a peer adds a microphone to the room
+     */
+    MediaAdded: OdinMediaAddedEvent;
+
+    /**
+     * Fired when a media stream was removed from a peer. This happens for example if a peer removes a microphone from the room
+     */
+    MediaRemoved: OdinMediaRemovedEvent;
+
+    /**
+     * Fired when a media stream was activated or deactivated. The active flag is true if the user started to talk and false if the user stopped talking.
+     */
+    MediaActivity: OdinMediaActivityEvent;
+
+    /**
+     * Fired when audio data is available for media streams. Audio comes in 16 bit and 32 bit float samples and are available individually for each peer.
+     * You can use the samples to record audio or send them to an AI for transcription.
+     */
+    AudioDataReceived: OdinAudioDataReceivedEvent;
+}
+
+export type OdinConnectionStateChangedEvent = (event: OdinConnectionStateChangedEventPayload) => void;
+export type OdinJoinedEvent = (event: OdinJoinedEventPayload) => void;
+export type OdinLeftEvent = (event: OdinLeftEventPayload) => void;
+export type OdinPeerJoinedEvent = (event: OdinPeerJoinedEventPayload) => void;
+export type OdinPeerLeftEvent = (event: OdinPeerLeftEventPayload) => void;
+export type OdinMessageReceivedEvent = (event: OdinMessageReceivedEventPayload) => void;
+export type OdinPeerUserDataChangedEvent = (event: OdinPeerUserDataChangedEventPayload) => void;
+export type OdinRoomUserDataChangedEvent = (event: OdinRoomUserDataChangedEventPayload) => void;
+export type OdinMediaAddedEvent = (event: OdinMediaAddedEventPayload) => void;
+export type OdinMediaRemovedEvent = (event: OdinMediaRemovedEventPayload) => void;
+export type OdinMediaActivityEvent = (event: OdinMediaActivityEventPayload) => void;
+export type OdinAudioDataReceivedEvent = (event: OdinAudioDataReceivedEventPayload) => void;
+
+/**
+ * The base event payload that is passed to all events.
+ */
+declare interface OdinEventPayload {
+    /**
+     * The name of the event that was fired (see keys of OdinEvents for possible values).
+     */
+    event: keyof OdinEvents;
+
+    /**
+     * An internal integer representing the type of the event. This is mainly used internally for testing purposes.
+     */
+    tag: number;
+}
+
+/**
+ * The payload for the Joined event.
+ */
+export declare interface OdinJoinedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the room that was joined. It's the same as the room id that was passed to join.
+     */
+    roomId: string;
+
+    /**
+     * The ID of the local peer.
+     */
+    ownPeerId: number;
+
+    /**
+     * The ID of the local user. It is the same as the user id that was passed to join.
+     */
+    ownUserId: string;
+
+    /**
+     * The current user data of the room
+     */
+    roomUserData: Uint8Array | undefined;
+}
+
+/**
+ * The payload for the Left event.
+ */
+export declare interface OdinLeftEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the room that was left. It's the same as the room id that was passed to join.
+     */
+    roomId: string;
+}
+
+/**
+ * The payload for the PeerJoined event.
+ */
+export declare interface OdinPeerJoinedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that joined.
+     */
+    peerId: number;
+
+    /**
+     * The ID of the user that joined.
+     */
+    userId: string;
+
+    /**
+     * The user data of the peer that joined.
+     */
+    userData: Uint8Array | undefined;
+}
+
+/**
+ * The payload for the PeerLeft event.
+ */
+export declare interface OdinPeerLeftEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that left.
+     */
+    peerId: number;
+}
+
+/**
+ * The payload for the PeerUserDataChanged event.
+ */
+export declare interface OdinPeerUserDataChangedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that changed the user data.
+     */
+    peerId: number;
+
+    /**
+     * The new user data of the peer.
+     */
+    userData: Uint8Array | undefined;
+}
+
+/**
+ * The payload for the RoomUserDataChanged event.
+ */
+export declare interface OdinRoomUserDataChangedEventPayload extends OdinEventPayload {
+    /**
+     * The new user data of the room.
+     */
+    userData: Uint8Array | undefined;
+}
+
+/**
+ * Connection states of the room
+ */
+export declare type OdinConnectionState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'unknown';
+
+/**
+ * Change reasons for the connection state
+ */
+export declare type OdinConnectionStateChangeReason = 'client_request' | 'server_request' | 'timeout' | 'unknown';
+
+/**
+ * The payload for the ConnectionStateChanged event.
+ */
+export declare interface OdinConnectionStateChangedEventPayload extends OdinEventPayload {
+    /**
+     * The new connection state of the room.
+     */
+    state: OdinConnectionState;
+
+    /**
+     * The error code if the connection state is Error.
+     */
+    reason: OdinConnectionStateChangeReason;
+}
+
+/**
+ * The payload for the MessageReceived event.
+ */
+export declare interface OdinMessageReceivedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that sent the message.
+     */
+    peerId: number;
+
+    /**
+     * The message data received from the peer.
+     */
+    messageData: Uint8Array;
+}
+
+/**
+ * The payload for the MediaAdded event.
+ */
+export declare interface OdinMediaAddedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that added the media.
+     */
+    peerId: number;
+
+    /**
+     * The ID of the media that was added.
+     */
+    mediaId: number;
+}
+
+/**
+ * The payload for the MediaRemoved event.
+ */
+export declare interface OdinMediaRemovedEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that removed the media.
+     */
+    peerId: number;
+
+    /**
+     * The ID of the media that was removed.
+     */
+    mediaId: number;
+}
+
+/**
+ * The payload for the MediaActivity event.
+ */
+export declare interface OdinMediaActivityEventPayload extends OdinEventPayload {
+    /**
+     * The ID of the peer that changed the media activity.
+     */
+    peerId: number;
+
+    /**
+     * The ID of the media that changed the activity.
+     */
+    mediaId: number;
+
+    /**
+     * Indicates if the media is currently active or not (i.e. user talking or not).
+     */
+    state: boolean;
+}
+
+/**
+ * The payload for the AudioDataReceived event.
+ */
+export declare interface OdinAudioDataReceivedEventPayload {
+    /**
+     * The ID of the peer that sent the audio data.
+     */
+    peerId: number;
+
+    /**
+     * The ID of the media that sent the audio data.
+     */
+    mediaId: number;
+
+    /**
+     * The audio data received from the peer as 16-bit PCM samples ranging from -32768 to 32767 as a byte array.
+     * Use `const samplesArray = new Int16Array(samples16.buffer)` to get an actual array
+     */
+    samples16: Uint8Array;
+
+    /**
+     * The audio data received from the peer as 32-bit PCM samples ranging from -1 to 1.
+     * Use `const floats = new Float32Array(samples32.buffer)` to get an actual array
+     */
+    samples32: Uint8Array;
+}
+
+/**
+ * Noise suppression levels
+ */
+export declare enum OdinNoiseSuppressionLevel {
+    /**
+     * Noise suppression is disabled
+     */
+    None = 0,
+
+    /**
+     * Use low suppression (6 dB)
+     */
+    Low = 1,
+
+    /**
+     * Use moderate suppression (12 dB)
+     */
+    Moderate = 2,
+
+    /**
+     * Use high suppression (18 dB)
+     */
+    High = 3,
+
+    /**
+     * Use very high suppression (21 dB)
+     */
+    VeryHigh = 4
+}
+
+export declare interface OdinAPMSettings {
+    /**
+     * Enables or disables voice activity detection (VAD)
+     */
+    voiceActivityDetection: boolean,
+
+    /**
+     * Voice probability value when the VAD should engage
+     */
+    voiceActivityDetectionAttackProbability: number,
+
+    /**
+     * Voice probability value when the VAD should disengage
+     */
+    voiceActivityDetectionReleaseProbability: number,
+
+    /**
+     * Enables or disables the input volume gate
+     */
+    volumeGate: boolean,
+
+    /**
+     * Root-mean-square power (dBFS) when the volume gate should engage
+     */
+    volumeGateAttackLoudness: number,
+
+    /**
+     * Root-mean-square power (dBFS) when the volume gate should disengage
+     */
+    volumeGateReleaseLoudness: number,
+
+    /**
+     * Enable or disable echo cancellation
+     */
+    echoCanceller: boolean,
+
+    /**
+     * Enable or disable high pass filtering
+     */
+    highPassFilter: boolean,
+
+    /**
+     * Enable or disable the pre amplifier
+     */
+    preAmplifier: boolean,
+
+    /**
+     * Set the aggressiveness of the suppression
+     */
+    noiseSuppressionLevel: OdinNoiseSuppressionLevel,
+
+    /**
+     * Enable or disable the transient suppressor
+     */
+    transientSuppressor: boolean,
+
+    /**
+     * Enable or disable the gain controller
+     */
+    gainController: boolean
+}
+
+/**
+ * The OdinRoom class. Use createRoom from OdinClient instance to create a room. The OdinRoom requires a token to connect
+ * to a room. OdinClients handles token creation for you, so its easier to just use OdinClient for room creation.
+ * Typical procedure is to create an OdinClient instance with an access key and call its `createRoom` function to create
+ * a room with a name and for a user id. Then add event listeners to the room and call `join` to connect to the room.
+ */
+export declare class OdinRoom {
+    /**
+     * Creates a new instance of a room with a token. Use OdinClient if you don't want to manage tokens yourself.
+     * @param token {string} The token to use for this room.
+     */
+    constructor(token: string);
+
+    /**
+     * Joins the room with the given gateway URL and optional user data.
+     * @param gatewayUrl {string} The gateway URL to connect to. Use gateway.odin.4players.io if you are unsure.
+     * @param userData {Uint8Array} The user data to send to the room. This can be used to identify the user.
+     */
+    join(gatewayUrl: string, userData?: Uint8Array): void;
+
+    /**
+     * Sends a message to the room.
+     * @param message {Uint8Array} The message to send as a byte array.
+     * @param peerIdList {number[]} The list of peer IDs to send the message to. If this is undefined, the message will be sent to all peers. If the list is defined and empty an error will be thrown.
+     */
+    sendMessage(message: Uint8Array, peerIdList?: number[]): void;
+
+    /**
+     * Adds an event listener to the room for specific events.
+     * @param event {Event} The event to listen for (see keys of OdinEvents for possible values)
+     * @param callback {(data: any) => void} The callback to call when the event is fired.
+     */
+    addEventListener<Event extends keyof OdinEvents>(eventName: Event, handler: OdinEvents[Event]): void;
+
+    /**
+     * Removes an event listener from the room for specific events.
+     * @param event {Event} The event to remove the listener from (see keys of OdinEvents for possible values)
+     */
+    removeEventListener<Event extends keyof OdinEvents>(eventName: Event): void;
+
+    /**
+     * Sets a global event listener that received all events, this can be helpful for debugging. Please use addEventListener instead for production code.
+     * @param callback {(data: any) => void} The callback to call when the event is fired.
+     */
+    setEventListener(callback: (data: OdinEventPayload) => void): void;
+
+    /**
+     * Updates the peer user data of the local peer
+     * @param userData {Uint8Array} The new user data to set.
+     */
+    updateOwnUserData(userData: Uint8Array): void;
+
+    /**
+     * Updates the room user data (for all peers)
+     * @param userData {Uint8Array} The new user data to set.
+     */
+    updateRoomUserData(userData: Uint8Array): void;
+
+    /**
+     * Closes the room and disconnects from the server.
+     */
+    close(): void;
+
+    /**
+     * Gets the ID of the room.
+     */
+    get id(): string;
+
+    /**
+     * Gets the ID of the local peer joined to the room.
+     */
+    get ownPeerId(): number;
+
+    /**
+     * Creates a local audio stream and adds it to the room. An OdinMedia object will be returned that allows you to send
+     * audio data.
+     * @param sampleRate {number} The sample rate of the audio stream. Can be between 8000 and 48000.
+     * @param channels {number} The number of channels of the audio stream. Can be 1 or 2.
+     */
+    createAudioStream(sampleRate: number, channels: number, apmSettings?: OdinAPMSettings): OdinMedia;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@4players/odin-nodejs",
+  "version": "0.7.0",
+  "description": "",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "scripts": {
+    "build:debug": "node-gyp rebuild --debug",
+    "build:release": "node-gyp rebuild",
+    "build": "npm run build:release",
+    "clean": "node-gyp clean",
+    "install": "node-gyp-build"
+  },
+  "keywords": [],
+  "author": "Phillip Schuster",
+  "license": "MIT",
+  "private": false,
+  "gypfile": true,
+  "type": "module",
+  "dependencies": {
+    "@4players/odin-foundation": "^0.1.3",
+    "@4players/odin-tokens": "^1.3.0",
+    "audio-buffer-stream": "^1.1.0",
+    "audio-decode": "^2.1.1",
+    "audio-lena": "^2.3.0",
+    "node-addon-api": "^5.1.0",
+    "node-gyp-build": "^4.6.0",
+    "openai": "^3.2.1",
+    "prompt-sync": "^4.2.0",
+    "segfault-handler": "^1.3.0",
+    "throttle": "^1.0.3",
+    "wav": "^1.0.2"
+  },
+  "devDependencies": {
+    "node-gyp": "^9.3.1",
+    "prebuildify": "^5.0.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}