feat(dtmf): expose duration/interToneGap and fix null safety on RTCDTMFSender

- Add `duration` and `interToneGap` params to `sendDtmf` on both the
  public wrapper and v1 implementation, forwarded directly to
  `RTCDTMFSender.insertDTMF()`. README previously stated these could
  not be controlled; that was incorrect for the native browser API.
- Guard `transceiver.sender.dtmf` before storing — the property is
  `RTCDTMFSender | null` per spec and the previous `!` assertion would
  throw in environments where DTMF is unsupported for a track.
- Add five unit tests covering: broadcast, targeted, parameterised,
  no-senders, and unknown-streamId paths.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: smoghe-bw

README.md

@@ -83,14 +83,17 @@ Please see the following resources for more information on MediaStreamConstraint
 
 ### DTMF
 
-- Description: send a set of VoIP-network-friendly DTMF tones. The tone amplitude and duration can not be controlled
+- Description: send DTMF tones via the browser's native `RTCDTMFSender` (RFC 4733). Tones are forwarded as telephone-event RTP packets by the Bandwidth gateway.
 - Params:
-  - tone: the digits to send, as a string, chosen from the set of valid DTMF characters [0-9,*,#,\,]
-  - streamId (optional): the stream to 'play' the tone on
+  - tone: the digits to send, as a string, chosen from the set of valid DTMF characters [0-9,*,#,A-D,\,]
+  - streamId (optional): the stream to send the tone on; defaults to all published streams
+  - duration (optional): tone duration in milliseconds, between 40 and 6000 (default: 100)
+  - interToneGap (optional): gap between tones in milliseconds, minimum 30 (default: 70)
 
 ```javascript
 bandwidthRtc.sendDtmf("3");
 bandwidthRtc.sendDtmf("313,3211*#");
+bandwidthRtc.sendDtmf("5", undefined, 200, 100); // 200ms tone, 100ms gap
 ```
 
 ## Event Listeners

src/bandwidthRtc.ts

@@ -211,12 +211,12 @@ class BandwidthRtc {
     return devices;
   }
 
-  sendDtmf(tone: string, streamId?: string) {
+  sendDtmf(tone: string, streamId?: string, duration?: number, interToneGap?: number) {
     if (!this.delegate) {
       throw new BandwidthRtcError("You must call 'connect' before 'sendDtmf'");
     }
 
-    return this.delegate.sendDtmf(tone, streamId);
+    return this.delegate.sendDtmf(tone, streamId, duration, interToneGap);
   }
 
   /**

src/v1/bandwidthRtc.test.ts

@@ -55,6 +55,70 @@ describe("bandwidhthRtcV1 constructor", () => {
   });
 });
 
+describe("bandwidthRtcV1 sendDtmf", () => {
+  beforeAll(() => {
+    setupNavigatorMocks();
+    setupMocks();
+  });
+
+  function makeDtmfSender() {
+    return { insertDTMF: jest.fn() };
+  }
+
+  test("calls insertDTMF on all registered senders when no streamId given", () => {
+    const brtc = new BandwidthRtc();
+    const sender1 = makeDtmfSender();
+    const sender2 = makeDtmfSender();
+    (brtc as any).localDtmfSenders.set("stream-1", sender1);
+    (brtc as any).localDtmfSenders.set("stream-2", sender2);
+
+    brtc.sendDtmf("5");
+
+    expect(sender1.insertDTMF).toHaveBeenCalledTimes(1);
+    expect(sender1.insertDTMF).toHaveBeenCalledWith("5", undefined, undefined);
+    expect(sender2.insertDTMF).toHaveBeenCalledTimes(1);
+    expect(sender2.insertDTMF).toHaveBeenCalledWith("5", undefined, undefined);
+  });
+
+  test("calls insertDTMF only on the specified stream when streamId given", () => {
+    const brtc = new BandwidthRtc();
+    const sender1 = makeDtmfSender();
+    const sender2 = makeDtmfSender();
+    (brtc as any).localDtmfSenders.set("stream-1", sender1);
+    (brtc as any).localDtmfSenders.set("stream-2", sender2);
+
+    brtc.sendDtmf("9", "stream-1");
+
+    expect(sender1.insertDTMF).toHaveBeenCalledTimes(1);
+    expect(sender2.insertDTMF).not.toHaveBeenCalled();
+  });
+
+  test("forwards duration and interToneGap to insertDTMF", () => {
+    const brtc = new BandwidthRtc();
+    const sender = makeDtmfSender();
+    (brtc as any).localDtmfSenders.set("stream-1", sender);
+
+    brtc.sendDtmf("1", undefined, 200, 80);
+
+    expect(sender.insertDTMF).toHaveBeenCalledWith("1", 200, 80);
+  });
+
+  test("does not throw when no senders are registered", () => {
+    const brtc = new BandwidthRtc();
+    expect(() => brtc.sendDtmf("5")).not.toThrow();
+  });
+
+  test("does nothing for an unknown streamId", () => {
+    const brtc = new BandwidthRtc();
+    const sender = makeDtmfSender();
+    (brtc as any).localDtmfSenders.set("stream-1", sender);
+
+    brtc.sendDtmf("5", "nonexistent");
+
+    expect(sender.insertDTMF).not.toHaveBeenCalled();
+  });
+});
+
 describe("bandwidthRtcV1 connect method", () => {
   beforeAll(() => {
     setupNavigatorMocks();

src/v1/bandwidthRtc.ts

@@ -274,15 +274,17 @@ export class BandwidthRtc {
   }
 
   /**
-   * DTMF Sender that layers DTMF tones onto an existing stream.
-   * @param tone The DTMF tones to send - a string composed of the characters [0-9,*,#,\,]*
-   * @param streamId The optional stream id to play on.
+   * Send DTMF tones via the browser's native RTCDTMFSender (RFC 4733).
+   * @param tone The DTMF tones to send - a string composed of the characters [0-9,*,#,A-D,\,]*
+   * @param streamId The optional stream id to send on; defaults to all published streams.
+   * @param duration Tone duration in milliseconds (default: 100). Must be between 40 and 6000.
+   * @param interToneGap Gap between tones in milliseconds (default: 70). Minimum 30.
    */
-  sendDtmf(tone: string, streamId?: string) {
+  sendDtmf(tone: string, streamId?: string, duration?: number, interToneGap?: number) {
     if (streamId) {
-      this.localDtmfSenders.get(streamId)?.insertDTMF(tone);
+      this.localDtmfSenders.get(streamId)?.insertDTMF(tone, duration, interToneGap);
     } else {
-      this.localDtmfSenders.forEach((dtmfSender) => dtmfSender.insertDTMF(tone));
+      this.localDtmfSenders.forEach((dtmfSender) => dtmfSender.insertDTMF(tone, duration, interToneGap));
     }
   }
 
@@ -639,9 +641,12 @@ export class BandwidthRtc {
         streams: [mediaStream],
       });
 
-      // Inject DTMF into one audio track in the stream
-      if (track.kind === "audio" && !this.localDtmfSenders.has(mediaStream.id)) {
-        this.localDtmfSenders.set(mediaStream.id, transceiver.sender.dtmf!);
+      // Inject DTMF into one audio track in the stream via the browser's native
+      // RTCDTMFSender. rtpSender.dtmf can be null when the browser doesn't
+      // support DTMF for this track, so guard before storing.
+      const dtmfSender = transceiver.sender.dtmf;
+      if (track.kind === "audio" && dtmfSender && !this.localDtmfSenders.has(mediaStream.id)) {
+        this.localDtmfSenders.set(mediaStream.id, dtmfSender);
       }
 
       if (codecPreferences) {