// Example filename: index.js

const { DeepgramClient } = require("@deepgram/sdk");
const fetch = require("cross-fetch");
const dotenv = require("dotenv");
dotenv.config();

// URL for the realtime streaming audio you would like to transcribe
const url = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service";

const live = async () => {
  // STEP 1: Create a Deepgram client using the API key
  const deepgram = new DeepgramClient({ apiKey: process.env.DEEPGRAM_API_KEY });

  // STEP 2: Create a live transcription connection with entity detection enabled
  const connection = await deepgram.listen.v1.connect({
    model: "nova-3",
    language: "en-US",
    smart_format: "true",
    detect_entities: "true",
  });

  // STEP 3: Listen for events from the live transcription connection
  connection.on("open", () => {
    console.log("Connection opened.");

    connection.on("close", () => {
      console.log("Connection closed.");
    });

    connection.on("message", (data) => {
      if (data.type === "Results") {
        const transcript = data.channel.alternatives[0].transcript;

        // Only process final results which contain entities
        if (data.is_final) {
          const entities = data.channel.alternatives[0].entities;

          if (entities && entities.length > 0) {
            console.log("\nTranscript:", transcript);
            console.log("Entities detected:");
            entities.forEach(entity => {
              console.log(`  - ${entity.label}: ${entity.value} (confidence: ${entity.confidence})`);
              // raw_value is present when formatting features (like smart_format) are enabled
              if (entity.raw_value) {
                console.log(`    Raw value: ${entity.raw_value}`);
              }
            });
          }
        }
      }
    });

    connection.on("error", (err) => {
      console.error("Error:", err);
    });

    // STEP 4: Fetch the audio stream and send it to the live transcription connection
    fetch(url)
      .then((r) => r.body)
      .then((res) => {
        res.on("readable", () => {
          connection.sendMedia(res.read());
        });
      });
  });

  connection.connect();
  await connection.waitForOpen();
};

live();

# Example filename: main.py

import httpx
import threading

from deepgram import DeepgramClient
from deepgram.core.events import EventType
from deepgram.listen.v1.types import ListenV1Results

# URL for the realtime streaming audio you would like to transcribe
URL = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service"

def main():
    try:
        # Create a Deepgram client
        deepgram = DeepgramClient()

        # Create a websocket connection with entity detection enabled
        with deepgram.listen.v1.connect(
            model="nova-3",
            language="en-US",
            smart_format=True,
            detect_entities=True
        ) as connection:

            def on_message(message) -> None:
                # Only process final results which contain entities
                if hasattr(message, 'is_final') and message.is_final:
                    if hasattr(message, 'channel') and hasattr(message.channel, 'alternatives'):
                        transcript = message.channel.alternatives[0].transcript
                        entities = message.channel.alternatives[0].entities

                        if entities and len(entities) > 0:
                            print(f"\nTranscript: {transcript}")
                            print("Entities detected:")
                            for entity in entities:
                                print(f"  - {entity.label}: {entity.value} (confidence: {entity.confidence})")
                                # raw_value is present when formatting features (like smart_format) are enabled
                                if hasattr(entity, 'raw_value') and entity.raw_value:
                                    print(f"    Raw value: {entity.raw_value}")

            connection.on(EventType.OPEN, lambda _: print("Connection opened"))
            connection.on(EventType.MESSAGE, on_message)
            connection.on(EventType.CLOSE, lambda _: print("Connection closed"))
            connection.on(EventType.ERROR, lambda error: print(f"Error: {error}"))

            lock_exit = threading.Lock()
            exit = False

            # Define a thread for start_listening with error handling
            def listening_thread():
                try:
                    connection.start_listening()
                except Exception as e:
                    print(f"Error in listening thread: {e}")

            # Start listening in a separate thread
            listen_thread = threading.Thread(target=listening_thread)
            listen_thread.start()

            # Define a worker thread for HTTP streaming with error handling
            def http_stream_thread():
                try:
                    with httpx.stream("GET", URL) as r:
                        for data in r.iter_bytes():
                            lock_exit.acquire()
                            if exit:
                                break
                            lock_exit.release()

                            connection.send_media(data)
                except Exception as e:
                    print(f"Error in HTTP streaming thread: {e}")

            # Start the HTTP streaming thread
            stream_thread = threading.Thread(target=http_stream_thread)
            stream_thread.start()

            # Wait for user input to stop
            input("Press Enter to stop...\n")
            lock_exit.acquire()
            exit = True
            lock_exit.release()

            # Wait for both threads to close
            stream_thread.join(timeout=5.0)
            listen_thread.join(timeout=5.0)

            print("Finished")

    except Exception as e:
        print(f"Could not open socket: {e}")
        return

if __name__ == "__main__":
    main()

const connection = await deepgram.listen.v1.connect({
  model: "nova-3",
  language: "en-US",
  detect_entities: "true",
  no_delay: "true"  // Forces immediate finalization, may miss entities
});

with deepgram.listen.v1.connect(
    model="nova-3",
    language="en-US",
    detect_entities=True,
    no_delay=True  # Forces immediate finalization, may miss entities
) as connection: