API Reference

import { transcribe } from 'cuttledoc'

const result = await transcribe('audio.mp3', {
  language: 'en',
  backend: 'auto'
})

console.log(result.text)
console.log(`Duration: ${result.durationSeconds}s`)

import { getAvailableBackends } from 'cuttledoc'

const backends = getAvailableBackends()
for (const backend of backends) {
  console.log(`${backend.name}: ${backend.isAvailable ? '✓' : '✗'}`)
}

import { setBackend, getBackend } from 'cuttledoc'

setBackend('apple') // Use Apple Speech
console.log(getBackend()) // "apple"

import { selectBestBackend } from 'cuttledoc'

const best = selectBestBackend('de') // Returns best backend for German

import { downloadModel } from 'cuttledoc'

await downloadModel('parakeet', 'parakeet-tdt-0.6b-v3')

import { cleanup } from 'cuttledoc'

await cleanup()

import { enhanceTranscript } from 'cuttledoc/llm'

const result = await transcribe('podcast.mp3')
const enhanced = await enhanceTranscript(result.text)

console.log(enhanced.markdown)
console.log(`Corrections: ${enhanced.stats.correctionsCount}`)

import { LLMProcessor } from 'cuttledoc/llm'

const processor = new LLMProcessor({
  model: 'gemma3n:e4b',
  gpuLayers: -1
})

await processor.initialize()
const result = await processor.enhance(rawText)
await processor.dispose()

import { downloadLLMModel } from 'cuttledoc/llm'

await downloadLLMModel('gemma3n:e4b', {
  onProgress: (progress) => console.log(`${progress}%`)
})

import { isLLMModelDownloaded } from 'cuttledoc/llm'

if (!isLLMModelDownloaded('gemma3n:e4b')) {
  await downloadLLMModel('gemma3n:e4b')
}

interface TranscribeOptions {
  language?: string // Language code (e.g., 'de', 'en-US')
  backend?: BackendType // Override default backend
  onProgress?: (partial: PartialResult) => void
}

interface TranscriptionResult {
  text: string // Full transcribed text
  segments: readonly TranscriptionSegment[]
  words?: readonly WordTimestamp[] // Parakeet/Canary only
  durationSeconds: number
  processingTimeSeconds: number
  language: string
  backend: BackendType
}

interface TranscriptionSegment {
  text: string
  startSeconds: number
  endSeconds: number
  confidence?: number
}

type BackendType = 'auto' | 'apple' | 'parakeet' | 'whisper' | 'canary'

interface LLMProcessResult {
  markdown: string // Formatted markdown
  plainText: string // Plain text version
  corrections: Array<{
    original: string
    corrected: string
  }>
  stats: {
    inputTokens: number
    outputTokens: number
    tokensPerSecond: number
    processingTimeSeconds: number
    paragraphCount: number
    correctionsCount: number
  }
}

const BACKEND_TYPES = {
  auto: 'auto',
  apple: 'apple',
  parakeet: 'parakeet',
  whisper: 'whisper',
  canary: 'canary'
} as const

const WHISPER_MODELS = {
  tiny: 'tiny',
  base: 'base',
  small: 'small',
  medium: 'medium',
  large: 'large'
} as const