fix: make temporary auth tokens actually work

Author: naomi-lgbt

examples/node-auth/index.js

@@ -1,16 +1,19 @@
-const { createClient } = require("../../dist/main/index");
+const { createClient, LiveTranscriptionEvents } = require("../../dist/main/index");
+const fetch = require("cross-fetch");
 
-const transcribeUrl = async () => {
-  const deepgram = createClient(process.env.DEEPGRAM_API_KEY);
+const demonstrateAuth = async () => {
+  // Note that the ENV value here is different than our other examples. The SDK will automatically grab `DEEPGRAM_API_KEY` if it exists,
+  // so by using a different name we can ensure that the second client is properly consuming the authentication token instead.
+  const deepgram = createClient({ key: process.env.DIFFERENT_DEEPGRAM_API_KEY });
   const { result: token, error: tokenError } = await deepgram.auth.grantToken();
   if (tokenError) {
     throw tokenError;
   }
-  console.log("Token", token);
+  console.log("Token", token.access_token);
 
   console.log("Transcribing URL", "https://dpgr.am/spacewalk.wav");
-  deepgram.token = token.access_token;
-  const { result, error } = await deepgram.listen.prerecorded.transcribeUrl(
+  const deepgramWithToken = createClient({ accessToken: token.access_token });
+  const { result, error } = await deepgramWithToken.listen.prerecorded.transcribeUrl(
     {
       url: "https://dpgr.am/spacewalk.wav",
     },
@@ -22,6 +25,86 @@ const transcribeUrl = async () => {
 
   if (error) console.error(error);
   if (!error) console.dir(result, { depth: 5 });
+
+  console.log("Transcribing live");
+
+  const url = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service";
+
+  let is_finals = [];
+
+  const connection = deepgramWithToken.listen.live({
+    model: "nova-3",
+    language: "en-US",
+    // Apply smart formatting to the output
+    smart_format: true,
+    // To get UtteranceEnd, the following must be set:
+    interim_results: true,
+    utterance_end_ms: 1000,
+    vad_events: true,
+    // Time in milliseconds of silence to wait for before finalizing speech
+    endpointing: 300,
+    // Keyterm Prompting allows you improve Keyword Recall Rate (KRR) for important keyterms or phrases up to 90%.
+    keyterm: ["BBC"],
+  });
+
+  connection.on(LiveTranscriptionEvents.Open, () => {
+    fetch(url)
+      .then((r) => r.body)
+      .then((res) => {
+        res.on("readable", () => {
+          connection.send(res.read());
+        });
+      });
+  });
+  connection.on(LiveTranscriptionEvents.Close, () => {
+    console.log("Connection closed.");
+  });
+
+  connection.on(LiveTranscriptionEvents.Metadata, (data) => {
+    console.log(`Deepgram Metadata: ${data}`);
+  });
+
+  connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+    const sentence = data.channel.alternatives[0].transcript;
+
+    // Ignore empty transcripts
+    if (sentence.length == 0) {
+      return;
+    }
+    if (data.is_final) {
+      // We need to collect these and concatenate them together when we get a speech_final=true
+      // See docs: https://developers.deepgram.com/docs/understand-endpointing-interim-results
+      is_finals.push(sentence);
+
+      // Speech final means we have detected sufficent silence to consider this end of speech
+      // Speech final is the lowest latency result as it triggers as soon an the endpointing value has triggered
+      if (data.speech_final) {
+        const utterance = is_finals.join(" ");
+        console.log(`Speech Final: ${utterance}`);
+        is_finals = [];
+      } else {
+        // These are useful if you need real time captioning and update what the Interim Results produced
+        console.log(`Is Final: ${sentence}`);
+      }
+    } else {
+      // These are useful if you need real time captioning of what is being spoken
+      console.log(`Interim Results: ${sentence}`);
+    }
+  });
+
+  connection.on(LiveTranscriptionEvents.UtteranceEnd, (_data) => {
+    const utterance = is_finals.join(" ");
+    console.log(`Deepgram UtteranceEnd: ${utterance}`);
+    is_finals = [];
+  });
+
+  connection.on(LiveTranscriptionEvents.SpeechStarted, (_data) => {
+    // console.log("Deepgram SpeechStarted");
+  });
+
+  connection.on(LiveTranscriptionEvents.Error, (err) => {
+    console.error(err);
+  });
 };
 
-transcribeUrl();
+demonstrateAuth();

src/lib/fetch.ts

@@ -29,15 +29,15 @@ export const resolveFetch = (customFetch?: Fetch): Fetch => {
  * @param customFetch - An optional custom fetch function to use instead of the global fetch function.
  * @returns A fetch function that can be used to make HTTP requests with the provided API key in the "Authorization" header.
  */
-export const fetchWithAuth = (apiKey: string, customFetch?: Fetch): Fetch => {
+export const fetchWithAuth = (apiKey: string, customFetch?: Fetch, token?: string): Fetch => {
   const fetch = resolveFetch(customFetch);
   const HeadersConstructor = resolveHeadersConstructor();
 
   return async (input, init) => {
     const headers = new HeadersConstructor(init?.headers);
 
     if (!headers.has("Authorization")) {
-      headers.set("Authorization", `Token ${apiKey}`);
+      headers.set("Authorization", token ? `Bearer ${token}` : `Token ${apiKey}`);
     }
 
     return fetch(input, { ...init, headers });

src/lib/types/DeepgramClientOptions.ts

@@ -58,6 +58,7 @@ export type DefaultClientOptions = {
  */
 export interface DeepgramClientOptions {
   key?: string | IKeyFactory;
+  accessToken?: string;
   global?: NamespaceOptions & { url?: string; headers?: { [index: string]: any } };
   listen?: NamespaceOptions;
   manage?: NamespaceOptions;

src/packages/AbstractClient.ts

@@ -24,6 +24,7 @@ export const noop = () => {};
 export abstract class AbstractClient extends EventEmitter {
   protected factory: Function | undefined = undefined;
   protected key: string;
+  protected accessToken: string | undefined = undefined;
   protected options: DefaultClientOptions;
   public namespace: string = "global";
   public version: string = "v1";
@@ -43,6 +44,10 @@ export abstract class AbstractClient extends EventEmitter {
   constructor(options: DeepgramClientOptions) {
     super();
 
+    if (options.accessToken) {
+      this.accessToken = options.accessToken;
+    }
+
     let key;
 
     if (typeof options.key === "function") {
@@ -56,8 +61,8 @@ export abstract class AbstractClient extends EventEmitter {
       key = process.env.DEEPGRAM_API_KEY as string;
     }
 
-    if (!key) {
-      throw new DeepgramError("A deepgram API key is required.");
+    if (!key && !this.accessToken) {
+      throw new DeepgramError("A deepgram API key or temporary auth token is required.");
     }
 
     this.key = key;

src/packages/AbstractLiveClient.ts

@@ -90,7 +90,11 @@ export abstract class AbstractLiveClient extends AbstractClient {
     }
 
     if (!("Authorization" in this.headers)) {
-      this.headers["Authorization"] = `Token ${key}`; // Add default token
+      if (this.accessToken) {
+        this.headers["Authorization"] = `Bearer ${this.accessToken}`; // Use token if available
+      } else {
+        this.headers["Authorization"] = `Token ${key}`; // Add default token
+      }
     }
   }
 
@@ -141,7 +145,10 @@ export abstract class AbstractLiveClient extends AbstractClient {
      * Native websocket transport (browser)
      */
     if (NATIVE_WEBSOCKET_AVAILABLE) {
-      this.conn = new WebSocket(requestUrl, ["token", this.namespaceOptions.key]);
+      this.conn = new WebSocket(
+        requestUrl,
+        this.accessToken ? ["bearer", this.accessToken] : ["token", this.namespaceOptions.key]
+      );
       this.setupConnection();
       return;
     }

src/packages/AbstractRestClient.ts

@@ -29,7 +29,7 @@ export abstract class AbstractRestClient extends AbstractClient {
       );
     }
 
-    this.fetch = fetchWithAuth(this.key, this.namespaceOptions.fetch.client);
+    this.fetch = fetchWithAuth(this.key, this.namespaceOptions.fetch.client, this.accessToken);
 
     if (this.proxy) {
       this.baseUrl = this.namespaceOptions.fetch.options.proxy!.url;