Building Your Ambient Scribe

import WebSocket from "ws";
import fs from "fs";

const TENANT_NAME = "YOUR_TENANT_NAME";
const ACCESS_TOKEN = "YOUR_ACCESS_TOKEN";
const INTERACTION_ID = "YOUR_INTERACTION_UUID"; // must be created via REST first
const ENVIRONMENT = "eu"; // or "us"

const WSS_URL = `wss://api.corti.ai/stream/${INTERACTION_ID}?environment=${ENVIRONMENT}&tenant-name=${TENANT_NAME}&token=${ACCESS_TOKEN}`;

const ws = new WebSocket(WSS_URL);

ws.on("open", () => {
  console.log("✅ WebSocket connected");

  // Step 1: Send config immediately (must be within 10 seconds)
  const config = {
    type: "config",
    configuration: {
      transcription: {
        primaryLanguage: "en",
        isDiarization: false,
        isMultichannel: false,
        participants: [
          { channel: 0, role: "multiple" }
        ]
      },
      mode: {
        type: "facts",      // or "transcription" if you don't need facts
        outputLocale: "en"
      }
    }
  };

  ws.send(JSON.stringify(config));
  console.log("📤 Sent config");
});

ws.on("message", (data) => {
  // Audio binary frames come back as Buffer — skip those
  if (Buffer.isBuffer(data) && !isJson(data)) return;

  const message = JSON.parse(data.toString());
  console.log("📨 Received:", JSON.stringify(message, null, 2));

  switch (message.type) {
    case "CONFIG_ACCEPTED":
      console.log("✅ Config accepted — session:", message.sessionId);
      // Step 2: Start sending audio now that config is accepted
      sendAudio();
      break;

    case "CONFIG_DENIED":
    case "CONFIG_MISSING":
    case "CONFIG_NOT_PROVIDED":
    case "CONFIG_TIMEOUT":
      console.error("❌ Config error:", message);
      ws.close();
      break;

    case "transcript":
      message.data.forEach((seg) => {
        console.log(`🗣  [${seg.time.start}s → ${seg.time.end}s] ${seg.transcript}`);
      });
      break;

    case "facts":
      message.fact.forEach((fact) => {
        console.log(`💡 Fact [${fact.group}]: ${fact.text}`);
      });
      break;

    case "flushed":
      console.log("🔄 Buffer flushed");
      break;

    case "usage":
      console.log(`💳 Credits used: ${message.credits}`);
      break;

    case "ENDED":
      console.log("🏁 Session ended — server closing socket");
      // ws closes automatically after this
      break;

    case "error":
      console.error("❌ Runtime error:", message.error);
      break;
  }
});

ws.on("close", (code, reason) => {
  console.log(`🔌 Connection closed [${code}]: ${reason}`);
});

ws.on("error", (err) => {
  console.error("🚨 WebSocket error:", err.message);
});

// --- Audio sending ---

function sendAudio() {
  const AUDIO_FILE = "./sample.webm"; // swap with your audio file path

  if (!fs.existsSync(AUDIO_FILE)) {
    console.warn("⚠️  No audio file found — sending silence simulation");
    simulateAudioAndEnd();
    return;
  }

  const audioBuffer = fs.readFileSync(AUDIO_FILE);
  const CHUNK_SIZE = 8192; // ~250–500ms chunks recommended
  let offset = 0;

  console.log(`🎙  Streaming ${audioBuffer.length} bytes of audio...`);

  const interval = setInterval(() => {
    if (ws.readyState !== WebSocket.OPEN) {
      clearInterval(interval);
      return;
    }

    if (offset >= audioBuffer.length) {
      clearInterval(interval);
      console.log("✅ All audio sent");
      endSession();
      return;
    }

    const chunk = audioBuffer.slice(offset, offset + CHUNK_SIZE);
    ws.send(chunk); // send raw binary — no JSON wrapping
    offset += CHUNK_SIZE;
  }, 300); // send a chunk every 300ms
}

function simulateAudioAndEnd() {
  // Demo: just wait a moment then end
  setTimeout(() => endSession(), 2000);
}

// --- Optional: flush the audio buffer mid-session ---
function flushBuffer() {
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: "flush" }));
    console.log("📤 Sent flush");
  }
}

// --- End the session ---
function endSession() {
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: "end" }));
    console.log("📤 Sent end — waiting for ENDED...");
  }
}

// Helper: check if a Buffer looks like JSON
function isJson(buf) {
  try {
    JSON.parse(buf.toString());
    return true;
  } catch {
    return false;
  }
}

// Corti API – Async Workflow
// 1. Create Interaction  2. Upload Recording  3. Generate Transcript  4. Extract Facts
// Docs: https://docs.corti.ai/workflows/ambient-async

const BASE_URL  = `https://api.${ENVIRONMENT}.corti.app/v2`;
const TENANT    = "YOUR_TENANT_NAME";
const TOKEN     = "YOUR_ACCESS_TOKEN"; // obtain via OAuth client_credentials flow

const headers = {
  "Authorization": `Bearer ${TOKEN}`,
  "Tenant-Name":   TENANT,
  "Content-Type":  "application/json",
};

// ─── STEP 1 · Create Interaction ────────────────────────────────────────────

async function createInteraction(): Promise<string> {
  const res = await fetch(`${BASE_URL}/interactions`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      encounter: {
        identifier: crypto.randomUUID(),
        status: "planned",
        type: "first_consultation",
        period: { startedAt: new Date().toISOString() },
      },
    }),
  });

  if (!res.ok) throw new Error(`Create interaction failed: ${res.status}`);

  const data = await res.json();
  const interactionId: string = data.id;

  console.log("✅ Interaction created:", interactionId);
  return interactionId;
}

// ─── STEP 2 · Upload Recording (full file as octet-stream) ──────────────────

async function uploadRecording(
  interactionId: string,
  audioBuffer: ArrayBuffer   // full recording file contents
): Promise<string> {
  const res = await fetch(`${BASE_URL}/interactions/${interactionId}/recordings/`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${TOKEN}`,
      "Tenant-Name":   TENANT,
      "Content-Type":  "application/octet-stream",
    },
    body: audioBuffer,
  });

  if (!res.ok) throw new Error(`Upload recording failed: ${res.status}`);

  const data = await res.json();
  const recordingId: string = data.recordingId;

  console.log("✅ Recording uploaded:", recordingId);
  return recordingId;
}

// ─── STEP 3 · Generate Transcript ───────────────────────────────────────────

async function createTranscript(
  interactionId: string,
  recordingId: string
): Promise<string> {
  const res = await fetch(`${BASE_URL}/interactions/${interactionId}/transcripts/`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      recordingId,
      primaryLanguage: "en",
      diarize: true,            // separate speakers
      isMultichannel: false,
      modelName: "base",        // "base" | "ensemble" | "symphony"
    }),
  });

  if (!res.ok) throw new Error(`Create transcript failed: ${res.status}`);

  const data = await res.json();
  const transcript: string = data.transcript ?? JSON.stringify(data);

  console.log("✅ Transcript generated");
  return transcript;
}

// ─── STEP 4 · Extract Facts ─────────────────────────────────────────────────

async function extractFacts(interactionId: string): Promise<object[]> {
  const res = await fetch(`${BASE_URL}/interactions/${interactionId}/facts/`, {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${TOKEN}`,
      "Tenant-Name":   TENANT,
    },
  });

  if (!res.ok) throw new Error(`Extract facts failed: ${res.status}`);

  const data = await res.json();
  const facts: object[] = data.facts ?? [];

  console.log(`✅ Facts extracted: ${facts.length} found`);
  return facts;
}

// ─── Orchestrate the full async workflow ────────────────────────────────────

async function runAsyncWorkflow(audioBuffer: ArrayBuffer) {
  try {
    const interactionId = await createInteraction();
    const recordingId   = await uploadRecording(interactionId, audioBuffer);
    const transcript    = await createTranscript(interactionId, recordingId);
    const facts         = await extractFacts(interactionId);

    return { interactionId, recordingId, transcript, facts };
  } catch (err) {
    console.error("Workflow error:", err);
    throw err;
  }
}

// ─── Example usage ──────────────────────────────────────────────────────────

// Load your audio file however is appropriate for your environment, e.g.:
// const audioBuffer = await fs.readFile("recording.mp3").then(b => b.buffer);

// runAsyncWorkflow(audioBuffer).then(result => console.log(result));

import { CortiEnvironment, CortiClient } from "@corti/sdk";

const client = new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET"
    },
    tenantName: "YOUR_TENANT_NAME"
});
await client.facts.create("f47ac10b-58cc-4372-a567-0e02b2c3d479", {
    facts: [{
            text: "text",
            group: "other"
        }]
});

import { CortiEnvironment, CortiClient } from "@corti/sdk";

const client = new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET"
    },
    tenantName: "YOUR_TENANT_NAME"
});
await client.facts.update("f47ac10b-58cc-4372-a567-0e02b2c3d479", "3c9d8a12-7f44-4b3e-9e6f-9271c2bbfa08");