@jambonz/mrf 0.1.8 → 0.1.14

package/lib/endpoint.js

@@ -75,6 +75,26 @@ class Endpoint extends EventEmitter {
   /** fsmrf api() passthrough: translate the FS api commands in use. */
   async api(command, args) {
     const arr = Array.isArray(args) ? args : (args ? String(args).split(' ') : []);
+    /* uuid_jambonz_licensing: outbound session-token (token-1) minting. FS's
+     * mod_jambonz_token exposed 'generate-session-token <uuid> <callId>'; route
+     * it to the mediajam licensing.generate-token control command and stash
+     * token-1 so a later ep.set('jambonz_session_token_2', …) can be validated
+     * against it. Returns FS's '+OK <token>' shape so the feature-server's
+     * existing parser is unchanged; on an unlicensed binary the control command
+     * errors and we return '-ERR' (the +OK check then simply skips the header). */
+    if (command === 'uuid_jambonz_licensing') {
+      if (arr[0] === 'generate-session-token') {
+        const callId = arr[2];
+        try {
+          const res = await this._request('licensing.generate-token', { callId });
+          this._sessionToken1 = res?.token || '';
+          return { body: this._sessionToken1 ? `+OK ${this._sessionToken1}` : '-ERR not licensed' };
+        } catch (err) {
+          return { body: `-ERR ${err.message}` };
+        }
+      }
+      return { body: '-ERR unsupported licensing command' };
+    }
     /* uuid_<vendor>_noise_isolation / uuid_<vendor>_turn_taking: the
      * noise-isolation and turn-taking task interfaces (space-delimited:
      * '<uuid> start <direction> [level] [model]' / '<uuid> start
@@ -130,9 +150,14 @@ class Endpoint extends EventEmitter {
         return { body: `-ERR ${err.message}` };
       }
     }
-    /* uuid_openai_s2s / uuid_voice_agent_s2s: the llm task interface.
-     * args arrive '^^|<uuid>|<command>[|...]'; map to s2s.* commands. */
-    const s2 = /^uuid_(openai|voice_agent)_s2s$/.exec(command);
+    /* uuid_<vendor>_s2s: the llm task interface. args arrive
+     * '^^|<uuid>|<command>[|...]'; map to s2s.* commands. ultravox passes
+     * only host/path (a pre-authenticated joinUrl — no authType/apiKey);
+     * elevenlabs prefixes in/out sample rates before host/path (the agent
+     * speaks fixed-rate pcm independent of the endpoint codec); assemblyai
+     * passes host/path/apiKey with no authType slot; google passes apiKey
+     * first then optional host/path (key rides a ?key= query param). */
+    const s2 = /^uuid_(openai|voice_agent|ultravox|elevenlabs|assemblyai|google)_s2s$/.exec(command);
     if (s2) {
       const vendor = s2[1];
       const raw = Array.isArray(args) ? args.join('|') : String(args || '');
@@ -141,9 +166,29 @@ class Endpoint extends EventEmitter {
       try {
         switch (cmd) {
           case 'session.create':
-            await this._request('s2s.start', {
-              vendor, host: parts[2], path: parts[3], authType: parts[4], apiKey: parts[5]
-            });
+            if (vendor === 'elevenlabs') {
+              /* args: inRate, outRate, host, path[, 'no_initial_config'] */
+              await this._request('s2s.start', {
+                vendor,
+                inRate: parseInt(parts[2], 10) || 0,
+                outRate: parseInt(parts[3], 10) || 0,
+                host: parts[4], path: parts[5]
+              });
+            } else if (vendor === 'assemblyai') {
+              /* args: host, path, apiKey (no authType slot) */
+              await this._request('s2s.start', {
+                vendor, host: parts[2], path: parts[3], apiKey: parts[4]
+              });
+            } else if (vendor === 'google') {
+              /* args: apiKey[, host[, path]] — key first, host/path optional */
+              await this._request('s2s.start', {
+                vendor, apiKey: parts[2], host: parts[3], path: parts[4]
+              });
+            } else {
+              await this._request('s2s.start', {
+                vendor, host: parts[2], path: parts[3], authType: parts[4], apiKey: parts[5]
+              });
+            }
             return { body: '+OK' };
           case 'client.event': {
             const event = JSON.parse(parts.slice(2).join('|'));
@@ -246,6 +291,15 @@ class Endpoint extends EventEmitter {
 
   async set(param, value) {
     const obj = typeof param === 'object' ? param : { [param]: value };
+    /* licensing: the SBC returns its token-2 as this channel var. Validate it
+     * against the token-1 we minted (FS parity: mod_jambonz_token). A bad
+     * token-2 means the call egressed through an unlicensed drachtio — tear the
+     * endpoint down (the media-tier backstop; the SBC is the primary gate). */
+    if ('jambonz_session_token_2' in obj) {
+      const token2 = obj.jambonz_session_token_2;
+      delete obj.jambonz_session_token_2;
+      await this._validateSessionToken2(token2);
+    }
     for (const [k, v] of Object.entries(obj)) {
       if (v === '' || v === null || v === undefined) delete this._channelVars[k];
       else this._channelVars[k] = String(v);
@@ -272,6 +326,23 @@ class Endpoint extends EventEmitter {
     return this.set(param, value);
   }
 
+  /* Validate the SBC's outbound token-2 against the stashed token-1. No-op when
+   * no token-1 was minted (unlicensed binary: licensing.generate-token returned
+   * nothing). On failure, signal an unexpected teardown ('destroy') so the
+   * feature-server drops the call — its media-timeout path already handles it. */
+  async _validateSessionToken2(token2) {
+    if (!this._sessionToken1 || !token2) return;
+    try {
+      await this._request('licensing.validate-token-2', { token1: this._sessionToken1, token2 });
+    } catch (err) {
+      if (this.connected) {
+        this.connected = false;
+        this.emit('destroy', { reason: 'license-violation', message: err.message });
+        this._request('endpoint.destroy', {}).catch(() => {});
+      }
+    }
+  }
+
   async modify(sdp) {
     const { localSdp } = await this._request('endpoint.modify', { remoteSdp: sdp });
     this.remote = parseSdp(sdp);
@@ -375,6 +446,13 @@ class Endpoint extends EventEmitter {
         sampleRate: opts.bidirectionalAudio.sampleRate || 0
       };
     }
+    /* HTTP Basic auth for the websocket upgrade. The feature-server sets it
+     * as MOD_AUDIO_BASIC_AUTH_* channel vars (ep.set) before forkAudioStart,
+     * exactly as mod_audio_fork consumed them; forward as wsAuth so mediajam
+     * adds the Authorization header. The recording server requires this. */
+    const username = opts.wsAuth?.username ?? this._channelVars.MOD_AUDIO_BASIC_AUTH_USERNAME;
+    const password = opts.wsAuth?.password ?? this._channelVars.MOD_AUDIO_BASIC_AUTH_PASSWORD;
+    if (username) data.wsAuth = {username, password: password || ''};
     await this._request('fork.start', data);
     return this;
   }

package/lib/mediaserver.js

@@ -137,6 +137,11 @@ class MediaServer extends EventEmitter {
     if (opts.remoteSdp) data.remoteSdp = opts.remoteSdp;
     if (opts.codecs) data.codecs = Array.isArray(opts.codecs) ? opts.codecs : [opts.codecs];
     if (opts.tags) data.tags = opts.tags;
+    /* licensing conduit: {callId, token} on an inbound call (mediajam validates
+     * the session token before allocating media), or {reason:'anchor-media'} to
+     * skip the token check while still enforcing the session cap (re-anchors and
+     * jambonz-originated outbound legs, which carry no inbound token). */
+    if (opts.license) data.license = opts.license;
     const options = {};
     if (opts.media_timeout) options.mediaTimeoutMs = parseInt(opts.media_timeout, 10);
     if (opts.media_hold_timeout) options.holdTimeoutMs = parseInt(opts.media_hold_timeout, 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/mrf",
-  "version": "0.1.8",
+  "version": "0.1.14",
   "main": "index.js",
   "scripts": {
     "test": "node --test",

package/test/licensing-conduit.test.js

@@ -0,0 +1,72 @@
+// Unit tests for the licensing conduit translation in the Endpoint adapter:
+// the FS uuid_jambonz_licensing api() and the jambonz_session_token_2 set()
+// are routed to mediajam's licensing.* control commands. The control transport
+// is mocked so these run without a server binary.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const Endpoint = require('../lib/endpoint');
+
+// Build an Endpoint whose control requests are captured in `calls`. `handler`
+// returns the response (or throws) per command.
+function makeEp(handler) {
+  const calls = [];
+  const ms = {
+    _connection: {
+      request: async (cmd, uuid, data) => {
+        calls.push({ cmd, data });
+        return handler ? handler(cmd, data) : {};
+      }
+    },
+    conn: {}
+  };
+  return { ep: new Endpoint(ms, 'ep-1', null, null), calls };
+}
+
+test('generate-session-token mints token-1 (FS +OK shape) and stashes it', async () => {
+  const { ep, calls } = makeEp((cmd) => (cmd === 'licensing.generate-token' ? { token: 'TOK1' } : {}));
+  const res = await ep.api('uuid_jambonz_licensing', 'generate-session-token ep-1 call-123');
+  assert.deepStrictEqual(calls[0], { cmd: 'licensing.generate-token', data: { callId: 'call-123' } });
+  assert.strictEqual(res.body, '+OK TOK1');
+  assert.strictEqual(ep._sessionToken1, 'TOK1');
+});
+
+test('unlicensed binary: generate returns -ERR (no token), feature-server then skips the header', async () => {
+  const { ep } = makeEp(() => { throw new Error('not licensed'); });
+  const res = await ep.api('uuid_jambonz_licensing', 'generate-session-token ep-1 call-9');
+  assert.match(res.body, /^-ERR/);
+  assert.ok(!ep._sessionToken1);
+});
+
+test('token-2 is validated against the stashed token-1', async () => {
+  const { ep, calls } = makeEp((cmd) => (cmd === 'licensing.generate-token' ? { token: 'TOK1' } : { valid: true }));
+  await ep.api('uuid_jambonz_licensing', 'generate-session-token ep-1 call-123');
+  await ep.set('jambonz_session_token_2', 'TOK2');
+  const v = calls.find((c) => c.cmd === 'licensing.validate-token-2');
+  assert.deepStrictEqual(v.data, { token1: 'TOK1', token2: 'TOK2' });
+  assert.strictEqual(ep.connected, true);
+});
+
+test('invalid token-2 tears the endpoint down (destroy)', async () => {
+  const { ep } = makeEp((cmd) => {
+    if (cmd === 'licensing.generate-token') return { token: 'TOK1' };
+    if (cmd === 'licensing.validate-token-2') throw new Error('session token 2 invalid');
+    return {};
+  });
+  await ep.api('uuid_jambonz_licensing', 'generate-session-token ep-1 call-123');
+  let destroyed = null;
+  ep.on('destroy', (evt) => { destroyed = evt; });
+  await ep.set('jambonz_session_token_2', 'BAD');
+  assert.strictEqual(ep.connected, false);
+  assert.strictEqual(destroyed.reason, 'license-violation');
+});
+
+test('token-2 with no token-1 (unlicensed) is a no-op — no validate call, no teardown', async () => {
+  const { ep, calls } = makeEp(() => { throw new Error('should not be called'); });
+  let destroyed = false;
+  ep.on('destroy', () => { destroyed = true; });
+  await ep.set('jambonz_session_token_2', 'X');
+  assert.ok(!calls.find((c) => c.cmd === 'licensing.validate-token-2'));
+  assert.strictEqual(destroyed, false);
+  assert.strictEqual(ep.connected, true);
+});