Streaming transcription

npm install @sullyai/sullyai ws

pip install --pre sullyai websockets

import { readFile } from "node:fs/promises";
import SullyAI from "@sullyai/sullyai";
import WebSocket from "ws";

const apiKey = process.env.SULLY_API_KEY;
const accountID = process.env.SULLY_ACCOUNT_ID;
const baseURL = process.env.SULLY_API_BASE_URL;

if (!apiKey || !accountID || !baseURL) {
  throw new Error("Missing Sully environment variables");
}

const client = new SullyAI({
  apiKey,
  accountID,
  baseURL,
});
type CreateStreamingTokenResponse = {
  data: { token: string };
};

const tokenResponse = await client.post<CreateStreamingTokenResponse>(
  "/v1/audio/transcriptions/stream/token",
  {
    body: { expiresIn: 300 },
    maxRetries: 0,
  },
);
const token = tokenResponse.data.token;

if (!token) throw new Error("Sully did not return a streaming token");

const url = new URL(
  "/v1/audio/transcriptions/stream",
  baseURL,
);
url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
url.searchParams.set("account_id", accountID);
url.searchParams.set("api_token", token);
url.searchParams.set("sample_rate", "16000");
url.searchParams.set("encoding", "linear16");

const socket = new WebSocket(url);
let audioComplete = false;
let closeTimer: ReturnType<typeof setTimeout> | undefined;

const closeAfterQuietPeriod = () => {
  clearTimeout(closeTimer);
  closeTimer = setTimeout(() => socket.close(1000, "Audio complete"), 2_000);
};

socket.on("message", async (raw) => {
  const message = JSON.parse(raw.toString());
  console.log(message);

  if (audioComplete) closeAfterQuietPeriod();

  if (message.type === "status" && message.status === "connected") {
    const audio = await readFile("./fictional-visit.pcm");
    for (let offset = 0; offset < audio.length; offset += 3_200) {
      const chunk = audio.subarray(offset, offset + 3_200);
      socket.send(JSON.stringify({ audio: chunk.toString("base64") }));
      await new Promise((resolve) => setTimeout(resolve, 100));
    }
    audioComplete = true;
    closeAfterQuietPeriod();
  }
});

socket.on("close", () => clearTimeout(closeTimer));

import asyncio
import base64
import json
import os
from urllib.parse import urlencode, urlsplit, urlunsplit

import httpx
from sullyai import SullyAI
from websockets.asyncio.client import connect

client = SullyAI(
    api_key=os.environ["SULLY_API_KEY"],
    account_id=os.environ["SULLY_ACCOUNT_ID"],
    base_url=os.environ["SULLY_API_BASE_URL"],
)
token_response = client.post(
    "/v1/audio/transcriptions/stream/token",
    cast_to=httpx.Response,
    body={"expiresIn": 300},
    options={"max_retries": 0},
)
token = token_response.json()["data"]["token"]
if not token:
    raise RuntimeError("Sully did not return a streaming token")

base = urlsplit(os.environ["SULLY_API_BASE_URL"])
query = urlencode(
    {
        "account_id": os.environ["SULLY_ACCOUNT_ID"],
        "api_token": token,
        "sample_rate": 16000,
        "encoding": "linear16",
    }
)
url = urlunsplit(
    (
        "wss" if base.scheme == "https" else "ws",
        base.netloc,
        "/v1/audio/transcriptions/stream",
        query,
        "",
    )
)


async def transcribe() -> None:
    async with connect(url) as socket:
        while True:
            raw = await socket.recv()
            message = json.loads(raw)
            print(message)
            if message.get("type") == "status" and message.get("status") == "connected":
                break

        with open("./fictional-visit.pcm", "rb") as audio:
            while chunk := audio.read(3_200):
                encoded = base64.b64encode(chunk).decode("ascii")
                await socket.send(json.dumps({"audio": encoded}))
                await asyncio.sleep(0.1)

        while True:
            try:
                raw = await asyncio.wait_for(socket.recv(), timeout=2.0)
            except asyncio.TimeoutError:
                break
            print(json.loads(raw))


asyncio.run(transcribe())