ターン検出を使用した OpenAI Realtime Transcription からの移行

pip install cartesia

npm i @cartesia/cartesia-js

import os
from cartesia import AsyncCartesia

client = AsyncCartesia(api_key=os.getenv("CARTESIA_API_KEY"))

async with client.stt.auto_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=24000
) as connection:
    ...

import os
from cartesia import Cartesia

client = Cartesia(api_key=os.getenv("CARTESIA_API_KEY"))

with client.stt.auto_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=24000
) as connection:
    ...

import Cartesia from "@cartesia/cartesia-js";

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

const connection = client.stt.autoFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_s16le",
  sample_rate: 24000,
});

// Server-side: Generate access-tokens using your API key
import Cartesia from '@cartesia/cartesia-js';

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

export async function GET() {
  const { token } = await client.accessToken.create({
    grants: { stt: true, tts: false, agent: false },
    // How long the token lasts in seconds
    // Allowed values: 0–3600
    expires_in: 3600,
  });
  return Response.json({ token });
}


// Client-side
// 1. Fetch an access token from your server
// 2. Connect to Cartesia via WebSocket
import Cartesia from "@cartesia/cartesia-js";

async function getToken(): Promise<string> {
  const res = await fetch('/replace-with-your-server');
  const { token } = await res.json();
  return token;
}
const audioContext = new AudioContext();

const client = new Cartesia({ token: await getToken() });

const connection = client.stt.autoFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_f32le",
  sample_rate: audioContext.sampleRate,
});

# raw_audio (bytes) - Raw audio data, about 100 ms at a time
await connection.send_raw(raw_audio)

# raw_audio (bytes) - Raw audio data, about 100 ms at a time
connection.send_raw(raw_audio)

// @param {ArrayBufferLike} rawAudio - raw audio data, about 100 ms at a time
connection.sendRaw(rawAudio);

from base64 import b64decode

await connection.send_raw(b64decode(audio_base_64))

from base64 import b64decode

connection.send_raw(b64decode(audio_base_64))

connection.sendRaw(Uint8Array.fromBase64(audioBase64));

# Commit buffered audio
# and let the server close the socket once done
await connection.send({"type": "close"})

# Close the socket early (optional)
connection.close()

# Commit buffered audio
# and let the server close the socket once done
connection.send({"type": "close"})

# Close the socket early (optional)
connection.close()

// Commit buffered audio
// and let the server close the socket once done
connection.send({ type: "close" });

// Close the socket early (optional)
connection.close()

import asyncio
from cartesia.types.stt import STTAutoFinalizeWebsocketResponse

full_transcript = ""

async def receive() -> None:
    global full_transcript
    async for event in connection:
        if event.type == "turn.start":
            print("speech_started")
        elif event.type == "turn.update":
            # cumulative within a turn
            print(f"Transcript so far: {event.transcript}")
        elif event.type == "turn.end":
            # Do not strip or add spaces!
            full_transcript += event.transcript
            print(f"speech_stopped: {event.transcript}")
        elif event.type == "error":
            print(f"error: {event.message}")

# Run receive() concurrently with your audio sender:
#   await asyncio.gather(send_audio(), receive())

from cartesia.types.stt import STTAutoFinalizeWebsocketResponse

full_transcript = ""

for event in connection:
    if event.type == "turn.start":
        print("speech_started")
    elif event.type == "turn.update":
        # cumulative within a turn
        print(f"Transcript so far: {event.transcript}")
    elif event.type == "turn.end":
        # Do not strip or add spaces!
        full_transcript += event.transcript
        print(f"speech_stopped: {event.transcript}")
    elif event.type == "error":
        print(f"error: {event.message}")

import Cartesia from '@cartesia/cartesia-js';

let fullTranscript = '';

for await (const event of connection.stream()) {
  if (event.type === 'message') {
    const m = event.message;
    switch (m.type) {
      case 'turn.start':
        console.log('speech_started');
        break;
      case 'turn.update':
        // cumulative within a turn
        console.log(`Transcript so far: ${m.transcript}`);
        break;
      case 'turn.end':
        // Do not trim or add spaces!
        fullTranscript += m.transcript;
        console.log(`speech_stopped: ${m.transcript}`);
        break;
    }
  } else if (event.type === 'error') {
    console.error(`error: ${event.error.message}`);
  }
}