STT

import { Socket, flag, text } from "@stream-io/calypso";

const live = await Socket.open(
  client.backend,
  await client.backend.socketURL("/v1/stt/stream"),
);
try {
  live.send({ type: "start", config_id: "my-router-name", stt: {} });

  live.sendAudio(pcm); // 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
  for await (const transcript of live.messages()) {
    if (transcript instanceof Uint8Array) continue;
    if (transcript.type === "transcript" && flag(transcript, "final")) {
      console.log(text(transcript, "text"));
    }
  }
} finally {
  live.close();
}

from vision_agents.core.stt import Transcript
from vision_agents.plugins import stream

client = stream.Client()
router = client.router("my-router-name")

async with router.stt.realtime() as live:
    await live.process_audio(pcm, participant)  # resampled to 16 kHz for you
    async for transcript in live.output:
        if isinstance(transcript, Transcript) and transcript.final:
            print(transcript.text)

router = api.router("my-router-name")

router.stt.realtime do |live|
  live.send_audio(pcm) # 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
  live.each do |frame|
    puts frame["text"] if frame["type"] == "transcript" && frame["final"]
  end
end

$live = $client->router('my-router-name')->stt->realtime();
try {
    $live->sendAudio($pcm); // 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
    foreach ($live->frames() as $frame) {
        if (is_array($frame) && $frame['type'] === 'transcript' && ($frame['final'] ?? false) === true) {
            echo $frame['text'], "\n";
        }
    }
} finally {
    $live->close();
}

live, err := client.Router("my-router-name").STT().Realtime(ctx, nil)
if err != nil {
	return err
}
defer live.Close()

if err := live.Send(pcm); err != nil { // 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
	return err
}
for transcript := range live.Transcripts() {
	if transcript.Final {
		fmt.Println(transcript.Text)
	}
}

await using var live = await client.Router("my-router-name").Stt.RealtimeAsync();

await live.SendAsync(pcm); // 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
await foreach (var transcript in live.ReadAllAsync())
{
    if (transcript.Final)
    {
        Console.WriteLine(transcript.Text);
    }
}

use vision_agents::types::SttOptions;

let mut live = client
    .router("my-router-name")
    .transcriber(SttOptions::default())
    .await?;

live.send_audio(&pcm).await?; // 16-bit PCM at 16 kHz, sent chunk by chunk as it is captured
while let Some(frame) = live.next().await {
    let frame = frame?;
    if frame.kind() == "transcript" && frame.flag("final") {
        println!("{}", frame.text("text"));
    }
}
live.close().await;

import { readFile } from "node:fs/promises";

let transcript = await client.post("/v1/stt/recordings", {
  body: {
    config_id: "my-recordings",
    source: { audio: (await readFile("interview.mp4")).toString("base64") },
  },
});
while (transcript.status === "queued" || transcript.status === "running") {
  await new Promise((resolve) => setTimeout(resolve, 1000));
  transcript = await client.get("/v1/stt/recordings/{id}", {
    path: { id: transcript.id },
  });
}
console.log(transcript.text);

from vision_agents.plugins import stream

router = stream.Client().router("my-recordings")

transcript = await router.stt.recording("interview.mp4")
print(transcript.text)

router = api.router("my-recordings")

transcript = router.stt.recording("interview.mp4")
puts transcript["text"]

use GetStream\VisionAgents\Generated\RecordingSource;

$transcript = $client->router('my-recordings')->stt->recording(
    new RecordingSource(audio: base64_encode(file_get_contents('interview.mp4'))),
);
echo $transcript->text, "\n";

recording, err := stream.File("interview.mp4")
if err != nil {
	return err
}
transcript, err := client.Router("my-recordings").STT().Recording(ctx, recording, nil)
if err != nil {
	return err
}
fmt.Println(*transcript.Text)

var transcript = await client.Router("my-recordings").Stt.RecordingAsync(Recorded.File("interview.mp4"));
Console.WriteLine(transcript.Text);

use vision_agents::Recording;
use vision_agents::types::SttOptions;

let transcript = client
    .router("my-recordings")
    .transcribe(
        Recording::Audio(std::fs::read("interview.mp4")?),
        SttOptions::default(),
        None,
    )
    .await?;
println!("{}", transcript.text.unwrap_or_default());