@otto-code/server 0.5.0

package/dist/server/server/speech/providers/local/sherpa/model-catalog.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+export const SHERPA_ONNX_MODEL_CATALOG = {
+    "parakeet-tdt-0.6b-v2-int8": {
+        kind: "stt-offline",
+        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8.tar.bz2",
+        extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8",
+        requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"],
+        label: "Parakeet v2 (English)",
+        description: "NVIDIA Parakeet TDT v2 (offline NeMo transducer, English).",
+        defaultFor: "stt",
+    },
+    "parakeet-tdt-0.6b-v3-int8": {
+        kind: "stt-offline",
+        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2",
+        extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8",
+        requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"],
+        label: "Parakeet v3 (25 languages)",
+        description: "NVIDIA Parakeet TDT v3 (offline NeMo transducer, 25 European languages, auto-detected).",
+    },
+    "kokoro-multi-lang-v1_0": {
+        kind: "tts",
+        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-multi-lang-v1_0.tar.bz2",
+        extractedDir: "kokoro-multi-lang-v1_0",
+        requiredFiles: [
+            "model.onnx",
+            "voices.bin",
+            "tokens.txt",
+            "lexicon-us-en.txt",
+            "lexicon-zh.txt",
+            "espeak-ng-data",
+        ],
+        label: "Kokoro v1.0",
+        description: "Kokoro TTS v1.0 (53 voices; EN, ES, FR, HI, IT, JA, PT, ZH).",
+        defaultFor: "tts",
+        tts: {
+            modelFile: "model.onnx",
+            lexiconFiles: ["lexicon-us-en.txt", "lexicon-zh.txt"],
+            defaultSpeakerId: 3, // af_heart
+        },
+    },
+    "kokoro-int8-multi-lang-v1_0": {
+        kind: "tts",
+        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-int8-multi-lang-v1_0.tar.bz2",
+        extractedDir: "kokoro-int8-multi-lang-v1_0",
+        requiredFiles: [
+            "model.int8.onnx",
+            "voices.bin",
+            "tokens.txt",
+            "lexicon-us-en.txt",
+            "lexicon-zh.txt",
+            "espeak-ng-data",
+        ],
+        label: "Kokoro v1.0 (int8)",
+        description: "Kokoro TTS v1.0 int8 (same 53 voices; smaller download, faster on CPU).",
+        tts: {
+            modelFile: "model.int8.onnx",
+            lexiconFiles: ["lexicon-us-en.txt", "lexicon-zh.txt"],
+            defaultSpeakerId: 3, // af_heart
+        },
+    },
+    "kokoro-en-v0_19": {
+        kind: "tts",
+        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-en-v0_19.tar.bz2",
+        extractedDir: "kokoro-en-v0_19",
+        requiredFiles: ["model.onnx", "voices.bin", "tokens.txt", "espeak-ng-data"],
+        label: "Kokoro v0.19 (legacy)",
+        description: "Kokoro TTS v0.19 (legacy; 11 English voices).",
+        tts: {
+            modelFile: "model.onnx",
+            lexiconFiles: [],
+            defaultSpeakerId: 0, // af
+        },
+    },
+};
+const ALL_MODEL_IDS = Object.keys(SHERPA_ONNX_MODEL_CATALOG).filter((k) => k in SHERPA_ONNX_MODEL_CATALOG);
+function isLocalSttModelId(id) {
+    return SHERPA_ONNX_MODEL_CATALOG[id].kind !== "tts";
+}
+function isLocalTtsModelId(id) {
+    return SHERPA_ONNX_MODEL_CATALOG[id].kind === "tts";
+}
+export const LOCAL_STT_MODEL_IDS = ALL_MODEL_IDS.filter(isLocalSttModelId);
+export const LOCAL_TTS_MODEL_IDS = ALL_MODEL_IDS.filter(isLocalTtsModelId);
+function resolveDefaultModelId(role) {
+    const match = ALL_MODEL_IDS.find((id) => {
+        const entry = SHERPA_ONNX_MODEL_CATALOG[id];
+        return entry.defaultFor === role;
+    });
+    if (!match) {
+        throw new Error(`No default model configured for role '${role}'`);
+    }
+    return match;
+}
+export const DEFAULT_LOCAL_STT_MODEL = resolveDefaultModelId("stt");
+export const DEFAULT_LOCAL_TTS_MODEL = resolveDefaultModelId("tts");
+function createModelIdSchema(modelIds) {
+    const validIds = new Set(modelIds);
+    return z
+        .string()
+        .trim()
+        .toLowerCase()
+        .refine((value) => validIds.has(value), {
+        message: "Invalid model id",
+    })
+        .transform((value) => value);
+}
+export const LocalSttModelIdSchema = createModelIdSchema(LOCAL_STT_MODEL_IDS);
+export const LocalTtsModelIdSchema = createModelIdSchema(LOCAL_TTS_MODEL_IDS);
+export function listSherpaOnnxModels() {
+    return ALL_MODEL_IDS.map((id) => Object.assign({ id }, SHERPA_ONNX_MODEL_CATALOG[id]));
+}
+export function getSherpaOnnxModelSpec(id) {
+    const spec = SHERPA_ONNX_MODEL_CATALOG[id];
+    if (!spec) {
+        throw new Error(`Unknown local speech model id: ${id}`);
+    }
+    return {
+        id,
+        ...spec,
+    };
+}
+export function getSherpaOnnxTtsLayout(id) {
+    const entry = SHERPA_ONNX_MODEL_CATALOG[id];
+    if (!entry.tts) {
+        throw new Error(`Local speech model '${id}' has no TTS layout`);
+    }
+    return entry.tts;
+}
+//# sourceMappingURL=model-catalog.js.map

package/dist/server/server/speech/providers/local/sherpa/model-downloader.d.ts

@@ -0,0 +1,16 @@
+import type pino from "pino";
+import { type SherpaOnnxModelId } from "./model-catalog.js";
+export interface EnsureSherpaOnnxModelOptions {
+    modelsDir: string;
+    modelId: SherpaOnnxModelId;
+    logger: pino.Logger;
+}
+export declare function getSherpaOnnxModelDir(modelsDir: string, modelId: SherpaOnnxModelId): string;
+export declare function resolveTarBinary(): string;
+export declare function ensureSherpaOnnxModel(options: EnsureSherpaOnnxModelOptions): Promise<string>;
+export declare function ensureSherpaOnnxModels(options: {
+    modelsDir: string;
+    modelIds: SherpaOnnxModelId[];
+    logger: pino.Logger;
+}): Promise<Record<SherpaOnnxModelId, string>>;
+//# sourceMappingURL=model-downloader.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/model-downloader.js

@@ -0,0 +1,195 @@
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync } from "node:fs";
+import { mkdir, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { getSherpaOnnxModelSpec, } from "./model-catalog.js";
+import { spawnProcess } from "../../../../../utils/spawn.js";
+export function getSherpaOnnxModelDir(modelsDir, modelId) {
+    const spec = getSherpaOnnxModelSpec(modelId);
+    return path.join(modelsDir, spec.extractedDir);
+}
+async function hasRequiredFiles(modelDir, requiredFiles) {
+    const results = await Promise.all(requiredFiles.map(async (rel) => {
+        const abs = path.join(modelDir, rel);
+        try {
+            const s = await stat(abs);
+            if (s.isDirectory()) {
+                return true;
+            }
+            return s.isFile() && s.size > 0;
+        }
+        catch {
+            return false;
+        }
+    }));
+    return results.every((present) => present);
+}
+async function downloadToFile(options) {
+    const { url, outputPath } = options;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
+    }
+    if (!res.body) {
+        throw new Error(`Failed to download ${url}: missing response body`);
+    }
+    const tmpPath = `${outputPath}.tmp-${Date.now()}`;
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    // The fetch ReadableStream type is slightly different from what Readable.fromWeb expects
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const nodeStream = Readable.fromWeb(res.body);
+    try {
+        await pipeline(nodeStream, createWriteStream(tmpPath));
+        await rename(tmpPath, outputPath);
+    }
+    catch (error) {
+        await rm(tmpPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+// A bare `tar` on Windows can resolve to Git's MSYS GNU tar (when Git's
+// usr\bin precedes System32 on PATH), which parses `C:\...` as a remote
+// `host:file` spec and dies with "Cannot connect to C: resolve failed"
+// (exit 128). The system bsdtar handles Windows paths and .tar.bz2 natively.
+export function resolveTarBinary() {
+    if (process.platform === "win32") {
+        const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
+        const systemTar = path.join(systemRoot, "System32", "tar.exe");
+        if (existsSync(systemTar)) {
+            return systemTar;
+        }
+    }
+    return "tar";
+}
+async function extractTarArchive(archivePath, destDir) {
+    await mkdir(destDir, { recursive: true });
+    await new Promise((resolve, reject) => {
+        const child = spawnProcess(resolveTarBinary(), ["xf", archivePath, "-C", destDir], {
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let stderr = "";
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else {
+                const detail = stderr.trim().slice(0, 500);
+                reject(new Error(`tar exited with code ${code}${detail ? `: ${detail}` : ""}`));
+            }
+        });
+    });
+}
+async function isNonEmptyFile(filePath) {
+    try {
+        const s = await stat(filePath);
+        return s.isFile() && s.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function computeFileSha256(filePath) {
+    const hash = createHash("sha256");
+    await pipeline(createReadStream(filePath), hash);
+    return hash.digest("hex");
+}
+// Refuse to extract an archive whose bytes don't match the pinned digest — the
+// guard against a compromised release asset or a MITM'd download. Throws on
+// mismatch (the caller deletes the bad archive); warns loudly when no digest is
+// pinned yet rather than silently trusting the download.
+async function verifyArchiveIntegrity(params) {
+    const { spec, archivePath, logger } = params;
+    if (!spec.sha256) {
+        logger.warn({ modelId: spec.id }, "No pinned sha256 for this model; extracting without archive integrity verification");
+        return;
+    }
+    const actual = await computeFileSha256(archivePath);
+    if (actual.toLowerCase() !== spec.sha256.toLowerCase()) {
+        throw new Error(`Model archive ${path.basename(archivePath)} failed integrity verification ` +
+            `(expected sha256 ${spec.sha256.toLowerCase()}, got ${actual}).`);
+    }
+    logger.info({ modelId: spec.id }, "Model archive integrity verified");
+}
+export async function ensureSherpaOnnxModel(options) {
+    const logger = options.logger.child({
+        module: "speech",
+        provider: "local",
+        component: "model-downloader",
+        modelId: options.modelId,
+    });
+    const spec = getSherpaOnnxModelSpec(options.modelId);
+    const modelDir = path.join(options.modelsDir, spec.extractedDir);
+    if (await hasRequiredFiles(modelDir, spec.requiredFiles)) {
+        return modelDir;
+    }
+    logger.info({ modelsDir: options.modelsDir }, "Starting model download");
+    try {
+        const downloadsDir = path.join(options.modelsDir, ".downloads");
+        const archiveFilename = path.basename(new URL(spec.archiveUrl).pathname);
+        const archivePath = path.join(downloadsDir, archiveFilename);
+        if (!(await isNonEmptyFile(archivePath))) {
+            await downloadToFile({
+                url: spec.archiveUrl,
+                outputPath: archivePath,
+            });
+        }
+        try {
+            await verifyArchiveIntegrity({ spec, archivePath, logger });
+            logger.info({
+                modelId: options.modelId,
+                archivePath,
+                modelDir,
+            }, "Extracting model archive");
+            await extractTarArchive(archivePath, options.modelsDir);
+            logger.info({
+                modelId: options.modelId,
+                modelDir,
+            }, "Verifying downloaded model files");
+            if (!(await hasRequiredFiles(modelDir, spec.requiredFiles))) {
+                throw new Error(`Downloaded and extracted ${archiveFilename}, but required files are still missing in ${modelDir}.`);
+            }
+        }
+        catch (error) {
+            // A corrupt, tampered, or incompletely-extracted archive must not wedge the
+            // model forever. Drop it so the next attempt re-downloads a fresh copy
+            // instead of re-verifying/re-extracting the same bad file.
+            await rm(archivePath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+        logger.info({
+            modelId: options.modelId,
+            archivePath,
+        }, "Finalizing model artifacts");
+        try {
+            await rm(archivePath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        logger.info({ modelDir }, "Model download completed");
+        return modelDir;
+    }
+    catch (error) {
+        logger.error({ err: error }, "Model download failed");
+        throw error;
+    }
+}
+export async function ensureSherpaOnnxModels(options) {
+    const uniq = Array.from(new Set(options.modelIds));
+    const entries = await Promise.all(uniq.map(async (id) => {
+        const modelPath = await ensureSherpaOnnxModel({
+            modelsDir: options.modelsDir,
+            modelId: id,
+            logger: options.logger,
+        });
+        return [id, modelPath];
+    }));
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return Object.fromEntries(entries);
+}
+//# sourceMappingURL=model-downloader.js.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-offline-recognizer.d.ts

@@ -0,0 +1,49 @@
+import type pino from "pino";
+export interface SherpaOfflineRecognizerModel {
+    kind: "nemo_transducer";
+    encoder: string;
+    decoder: string;
+    joiner: string;
+    tokens: string;
+}
+export interface SherpaOfflineRecognizerConfig {
+    model: SherpaOfflineRecognizerModel;
+    numThreads?: number;
+    provider?: "cpu";
+    debug?: 0 | 1;
+    sampleRate?: number;
+    featureDim?: number;
+    decodingMethod?: "greedy_search";
+    maxActivePaths?: number;
+}
+interface SherpaOfflineRecognizerNative {
+    config?: {
+        featConfig?: {
+            sampleRate?: number;
+        };
+    };
+    createStream: () => unknown;
+    decode: (stream: unknown) => void;
+    getResult: (stream: unknown) => {
+        text?: string;
+    } | string | undefined;
+    free?: () => void;
+}
+interface SherpaOfflineStreamNative {
+    acceptWaveform: ((arg: {
+        samples: Float32Array;
+        sampleRate: number;
+    }) => void) & ((sampleRate: number, samples: Float32Array) => void);
+    free?: () => void;
+}
+export declare class SherpaOfflineRecognizerEngine {
+    readonly recognizer: SherpaOfflineRecognizerNative;
+    readonly sampleRate: number;
+    private readonly logger;
+    constructor(config: SherpaOfflineRecognizerConfig, logger: pino.Logger);
+    createStream(): SherpaOfflineStreamNative;
+    acceptWaveform(stream: SherpaOfflineStreamNative, sampleRate: number, samples: Float32Array): void;
+    free(): void;
+}
+export {};
+//# sourceMappingURL=sherpa-offline-recognizer.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-offline-recognizer.js

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+import { loadSherpaOnnxNode } from "./sherpa-onnx-node-loader.js";
+function assertFileExists(filePath, label) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Missing ${label}: ${filePath}`);
+    }
+}
+export class SherpaOfflineRecognizerEngine {
+    constructor(config, logger) {
+        this.logger = logger.child({
+            module: "speech",
+            provider: "local",
+            component: "offline-recognizer",
+        });
+        assertFileExists(config.model.encoder, "offline encoder");
+        assertFileExists(config.model.decoder, "offline decoder");
+        assertFileExists(config.model.joiner, "offline joiner");
+        assertFileExists(config.model.tokens, "tokens");
+        const sherpa = loadSherpaOnnxNode();
+        const recognizerConfig = {
+            featConfig: {
+                sampleRate: config.sampleRate ?? 16000,
+                featureDim: config.featureDim ?? 80,
+            },
+            modelConfig: {
+                transducer: {
+                    encoder: config.model.encoder,
+                    decoder: config.model.decoder,
+                    joiner: config.model.joiner,
+                },
+                tokens: config.model.tokens,
+                modelType: "nemo_transducer",
+                numThreads: config.numThreads ?? 1,
+                provider: config.provider ?? "cpu",
+                debug: config.debug ?? 0,
+            },
+            decodingMethod: config.decodingMethod ?? "greedy_search",
+            maxActivePaths: config.maxActivePaths ?? 4,
+        };
+        this.recognizer = new sherpa.OfflineRecognizer(recognizerConfig);
+        const sr = this.recognizer?.config?.featConfig?.sampleRate;
+        this.sampleRate =
+            typeof sr === "number" && Number.isFinite(sr) && sr > 0
+                ? sr
+                : recognizerConfig.featConfig.sampleRate;
+        this.logger.info({ sampleRate: this.sampleRate, numThreads: recognizerConfig.modelConfig.numThreads }, "Sherpa offline recognizer initialized");
+    }
+    createStream() {
+        return this.recognizer.createStream();
+    }
+    acceptWaveform(stream, sampleRate, samples) {
+        if (!stream || typeof stream.acceptWaveform !== "function") {
+            throw new Error("Unexpected sherpa offline stream: missing acceptWaveform()");
+        }
+        // sherpa-onnx-node expects: acceptWaveform({ samples, sampleRate })
+        // sherpa-onnx (WASM) expects: acceptWaveform(sampleRate, samples)
+        if (stream.acceptWaveform.length <= 1) {
+            stream.acceptWaveform({ samples, sampleRate });
+        }
+        else {
+            stream.acceptWaveform(sampleRate, samples);
+        }
+    }
+    free() {
+        try {
+            this.recognizer?.free?.();
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Failed to free sherpa offline recognizer");
+        }
+    }
+}
+//# sourceMappingURL=sherpa-offline-recognizer.js.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.d.ts

@@ -0,0 +1,9 @@
+export interface SherpaOnnxNodeModule {
+    OfflineRecognizer: new (config: unknown) => unknown;
+    OnlineRecognizer?: new (config: unknown) => unknown;
+    OfflineTts?: new (config: unknown) => unknown;
+    Vad?: new (config: unknown, bufferSizeInSeconds: number) => unknown;
+    CircularBuffer?: new (capacity: number) => unknown;
+}
+export declare function loadSherpaOnnxNode(): SherpaOnnxNodeModule;
+//# sourceMappingURL=sherpa-onnx-node-loader.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.js

@@ -0,0 +1,107 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { applySherpaLoaderEnv, resolveSherpaLoaderEnv, sherpaPlatformPackageName, } from "./sherpa-runtime-env.js";
+import { createExternalCommandProcessEnv } from "../../../../otto-env.js";
+let cached = null;
+function appendAttempt(attempts, target, error) {
+    attempts.push({ target, error });
+}
+function formatError(error) {
+    if (!error) {
+        return "unknown error";
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function maybePatchLinuxAddonRunpath(addonPath) {
+    if (process.platform !== "linux") {
+        return;
+    }
+    const patchelfEnv = createExternalCommandProcessEnv("patchelf", process.env);
+    const patchelfCheck = spawnSync("patchelf", ["--version"], {
+        env: patchelfEnv,
+        stdio: "ignore",
+    });
+    if (patchelfCheck.status !== 0) {
+        return;
+    }
+    const currentRpath = spawnSync("patchelf", ["--print-rpath", addonPath], {
+        encoding: "utf8",
+        env: patchelfEnv,
+    });
+    if (currentRpath.status !== 0) {
+        return;
+    }
+    const rpath = (currentRpath.stdout ?? "").trim();
+    if (rpath.includes("$ORIGIN")) {
+        return;
+    }
+    spawnSync("patchelf", ["--set-rpath", "$ORIGIN", addonPath], {
+        env: patchelfEnv,
+        stdio: "ignore",
+    });
+}
+function loadWithRequire(requireFn, target, attempts) {
+    try {
+        return requireFn(target);
+    }
+    catch (error) {
+        appendAttempt(attempts, target, error);
+        return null;
+    }
+}
+function buildFailure(attempts, pkgName) {
+    const details = attempts
+        .map((attempt) => `- ${attempt.target}: ${formatError(attempt.error)}`)
+        .join("\n");
+    const message = [
+        `Failed to load sherpa-onnx-node for ${process.platform}-${process.arch}.`,
+        `Node ${process.version} (ABI ${process.versions.modules}).`,
+        `Platform package: ${pkgName}.`,
+        "Load attempts:",
+        details || "- (no attempts made)",
+    ].join("\n");
+    return new Error(message);
+}
+export function loadSherpaOnnxNode() {
+    if (cached) {
+        return cached;
+    }
+    const require = createRequire(import.meta.url);
+    const attempts = [];
+    // Pass through upstream support matrix first.
+    const direct = loadWithRequire(require, "sherpa-onnx-node", attempts);
+    if (direct) {
+        cached = direct;
+        return cached;
+    }
+    // sherpa-onnx-node depends on a platform-specific package (e.g. sherpa-onnx-darwin-arm64)
+    // that contains the native addon and shared libraries.
+    const pkgName = sherpaPlatformPackageName();
+    const resolvedEnv = resolveSherpaLoaderEnv();
+    const platformPkgDir = resolvedEnv?.libDir ?? null;
+    if (platformPkgDir) {
+        applySherpaLoaderEnv(process.env);
+        const addonPath = path.join(platformPkgDir, "sherpa-onnx.node");
+        if (existsSync(addonPath)) {
+            const byPath = loadWithRequire(require, addonPath, attempts);
+            if (byPath) {
+                cached = byPath;
+                return cached;
+            }
+            // Linux fallback for broken prebuilt RUNPATHs.
+            maybePatchLinuxAddonRunpath(addonPath);
+            const afterPatch = loadWithRequire(require, addonPath, attempts);
+            if (afterPatch) {
+                cached = afterPatch;
+                return cached;
+            }
+        }
+    }
+    throw buildFailure(attempts, pkgName);
+}
+//# sourceMappingURL=sherpa-onnx-node-loader.js.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-parakeet-realtime-session.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from "node:events";
+import type { StreamingTranscriptionSession } from "../../../speech-provider.js";
+import { SherpaOfflineRecognizerEngine } from "./sherpa-offline-recognizer.js";
+export declare class SherpaParakeetRealtimeTranscriptionSession extends EventEmitter implements StreamingTranscriptionSession {
+    private readonly engine;
+    private connected;
+    readonly requiredSampleRate: number;
+    private currentSegmentId;
+    private previousSegmentId;
+    private lastPartialText;
+    private pcm16;
+    private lastDecodeAt;
+    private decoding;
+    private pendingDecode;
+    private readonly minDecodeIntervalMs;
+    constructor(params: {
+        engine: SherpaOfflineRecognizerEngine;
+        minDecodeIntervalMs?: number;
+    });
+    connect(): Promise<void>;
+    appendPcm16(chunk: Buffer): void;
+    commit(): void;
+    clear(): void;
+    close(): void;
+    private maybeDecode;
+    private decodeNow;
+}
+//# sourceMappingURL=sherpa-parakeet-realtime-session.d.ts.map