Stream analysis

const WS_URL = "wss://api.interhuman.ai/v1/stream/analyze";
const apiKey = "YOUR_API_KEY"; // In production, do not hardcode—use your app's auth flow.

const ws = new WebSocket(WS_URL, apiKey);
ws.binaryType = "arraybuffer";

ws.addEventListener("open", () => {
  const sessionConfig = {
    include: [
      "conversation_quality_overall",
      "conversation_quality_timeline",
    ],
  };
  ws.send(JSON.stringify(sessionConfig));
});

ws.addEventListener("message", (event) => {
  if (typeof event.data !== "string") return;
  const payload = JSON.parse(event.data);
  console.log(payload.type, payload);
});

import asyncio
import json
import os

import websockets

WS_URL = "wss://api.interhuman.ai/v1/stream/analyze"


async def connect():
    api_key = os.environ["API_KEY"]
    headers = {"Authorization": f"Bearer {api_key}"}

    ws = await websockets.connect(
        WS_URL,
        additional_headers=headers,
        max_size=None,
    )

    session_config = {
        "include": [
            "conversation_quality_overall",
            "conversation_quality_timeline",
        ],
    }
    await ws.send(json.dumps(session_config))
    return ws


# Example: ws = asyncio.run(connect())

const mediaStream = await navigator.mediaDevices.getUserMedia({
  video: true,
  audio: true,
});

const preview = document.querySelector("#preview");
preview.srcObject = mediaStream;
preview.play();

import cv2

cap = cv2.VideoCapture(0)
if not cap.isOpened():
    raise RuntimeError("Could not open camera (device index 0)")

# Optional local preview while you build:
ok, frame = cap.read()
if ok:
    cv2.imshow("preview", frame)

const SEGMENT_MS = 3000;

const mimeType =
  ["video/webm;codecs=vp9,opus", "video/webm;codecs=vp8,opus", "video/webm"].find(
    (m) => MediaRecorder.isTypeSupported(m)
  ) || "";

const recorder = new MediaRecorder(
  mediaStream,
  mimeType ? { mimeType } : undefined
);

recorder.addEventListener("dataavailable", async (event) => {
  if (!event.data || event.data.size === 0) return;
  if (ws.readyState !== WebSocket.OPEN) return;

  const buffer = await event.data.arrayBuffer();
  ws.send(buffer);
});

// Call once the WebSocket is open and session config is sent:
recorder.start(SEGMENT_MS);

import asyncio
import time

import cv2

SEGMENT_SECONDS = 3
SEGMENT_PATH = "segment.mp4"


def record_segment(cap: cv2.VideoCapture, path: str, seconds: float) -> None:
    fps = cap.get(cv2.CAP_PROP_FPS) or 20.0
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
    writer = cv2.VideoWriter(path, fourcc, fps, (width, height))

    deadline = time.time() + seconds
    while time.time() < deadline:
        ok, frame = cap.read()
        if ok:
            writer.write(frame)
    writer.release()


async def send_segment(ws) -> None:
    record_segment(cap, SEGMENT_PATH, SEGMENT_SECONDS)
    with open(SEGMENT_PATH, "rb") as f:
        await ws.send(f.read())

    msg = await asyncio.wait_for(ws.recv(), timeout=60.0)
    print(msg)


# After connect(): asyncio.run(send_segment(ws))

if (recorder && recorder.state !== "inactive") {
  recorder.stop();
}
ws.close();
mediaStream.getTracks().forEach((track) => track.stop());

cap.release()
await ws.close()
cv2.destroyAllWindows()  # if you opened a preview window