transcribe()

import { RunAnywhere } from '@runanywhere/core'

// Transcribe an audio file
const result = await RunAnywhere.transcribeFile('/path/to/audio.wav', {
  language: 'en',
})

console.log('Transcription:', result.text)
console.log('Confidence:', result.confidence)
console.log('Duration:', result.duration, 'seconds')

import { RunAnywhere, ModelCategory } from '@runanywhere/core'
import { ONNX, ModelArtifactType } from '@runanywhere/onnx'

// 1. Initialize SDK and register ONNX backend
await RunAnywhere.initialize({ environment: SDKEnvironment.Development })
ONNX.register()

// 2. Add Whisper model
await ONNX.addModel({
  id: 'whisper-tiny-en',
  name: 'Whisper Tiny English',
  url: 'https://github.com/RunanywhereAI/sherpa-onnx/releases/download/runanywhere-models-v1/sherpa-onnx-whisper-tiny.en.tar.gz',
  modality: ModelCategory.SpeechRecognition,
  artifactType: ModelArtifactType.TarGzArchive,
  memoryRequirement: 75_000_000,
})

// 3. Download model
await RunAnywhere.downloadModel('whisper-tiny-en', (progress) => {
  console.log(`Download: ${(progress.progress * 100).toFixed(1)}%`)
})

// 4. Load model
const modelInfo = await RunAnywhere.getModelInfo('whisper-tiny-en')
await RunAnywhere.loadSTTModel(modelInfo.localPath, 'whisper')

await RunAnywhere.transcribeFile(
  audioPath: string,
  options?: STTOptions
): Promise<STTResult>

await RunAnywhere.transcribe(
  audioData: string,
  options?: STTOptions
): Promise<STTResult>

await RunAnywhere.transcribeBuffer(
  samples: number[],
  sampleRate: number,
  options?: STTOptions
): Promise<STTResult>

interface STTOptions {
  /** Language code (e.g., 'en', 'es', 'fr') */
  language?: string

  /** Enable punctuation in output */
  punctuation?: boolean

  /** Enable speaker diarization */
  diarization?: boolean

  /** Enable word-level timestamps */
  wordTimestamps?: boolean

  /** Audio sample rate (default: 16000) */
  sampleRate?: number
}

interface STTResult {
  /** Main transcription text */
  text: string

  /** Segments with timing information */
  segments: STTSegment[]

  /** Detected language code */
  language?: string

  /** Overall confidence (0.0 - 1.0) */
  confidence: number

  /** Audio duration in seconds */
  duration: number

  /** Alternative transcriptions */
  alternatives: STTAlternative[]
}

interface STTSegment {
  /** Segment text */
  text: string

  /** Start time in seconds */
  startTime: number

  /** End time in seconds */
  endTime: number

  /** Speaker ID (if diarization enabled) */
  speakerId?: string

  /** Segment confidence */
  confidence: number
}

// Simple transcription
const result = await RunAnywhere.transcribeFile('/path/to/recording.wav')
console.log(result.text)

// With language hint
const spanish = await RunAnywhere.transcribeFile('/path/to/spanish.wav', {
  language: 'es',
})
console.log(spanish.text)

const result = await RunAnywhere.transcribeFile(audioPath, {
  language: 'en',
  wordTimestamps: true,
})

// Display words with timing
for (const segment of result.segments) {
  console.log(
    `[${segment.startTime.toFixed(2)}s - ${segment.endTime.toFixed(2)}s]: ${segment.text}`
  )
}

// If you have raw audio samples (e.g., from a real-time stream)
const audioSamples: number[] = [] // Float32 samples from microphone

const result = await RunAnywhere.transcribeBuffer(
  audioSamples,
  16000, // Sample rate
  { language: 'en' }
)

console.log(result.text)

import { isSDKError, SDKErrorCode } from '@runanywhere/core'

try {
  const result = await RunAnywhere.transcribeFile(audioPath)
} catch (error) {
  if (isSDKError(error)) {
    switch (error.code) {
      case SDKErrorCode.notInitialized:
        console.error('SDK not initialized')
        break
      case SDKErrorCode.modelNotLoaded:
        console.error('Load an STT model first')
        break
      case SDKErrorCode.sttFailed:
        console.error('Transcription failed:', error.message)
        break
    }
  }
}