@rimelabs/sdk 0.1.0-alpha.1 → 0.1.0-alpha.12

package/dist/stt/stream.js

@@ -0,0 +1,224 @@
+import { abortable, scope } from "../cancellation.js";
+import { RimeError, RimeInputError, RimeCancelledError, RimeTimeoutError, RimeStreamError, } from "../errors.js";
+import { InputAudio } from "./audio.js";
+import { TranscriptQueue } from "./queue.js";
+import { TranscriptState } from "./protocol.js";
+import { TranscriptionCall } from "./transport.js";
+import { policy } from "./policy.js";
+/** Lazy, single-consumer stream. Source exhaustion commits input; return/cancel aborts it. */
+export class TranscriptStream {
+    owner;
+    source;
+    options;
+    controller = new AbortController();
+    queue = new TranscriptQueue(policy.queuedUpdates);
+    timers = new Set();
+    worker = null;
+    workerFinished = false;
+    call = null;
+    failure = null;
+    reading = false;
+    finished = false;
+    inputDone = false;
+    accepted;
+    acceptance = new Promise((resolve) => {
+        this.accepted = resolve;
+    });
+    admission = null;
+    completion = null;
+    externalAbort = () => this.fail(new RimeCancelledError("Transcription cancelled"));
+    constructor(owner, source, options) {
+        this.owner = owner;
+        this.source = source;
+        this.options = options;
+    }
+    /** Server request identity, available once response headers arrive. */
+    get requestId() {
+        return this.call?.requestId ?? null;
+    }
+    deadline(seconds, message) {
+        const timer = scope([], seconds, new RimeTimeoutError(message));
+        timer.signal.addEventListener("abort", () => this.fail(timer.signal.reason), { once: true });
+        if (timer.signal.aborted)
+            this.fail(timer.signal.reason);
+        this.timers.add(timer);
+        return timer;
+    }
+    start() {
+        if (this.failure)
+            throw this.failure;
+        if (this.finished || this.worker)
+            return;
+        this.owner.checkOpen();
+        if (this.options.signal?.aborted) {
+            this.externalAbort();
+            throw this.failure;
+        }
+        this.options.signal?.addEventListener("abort", this.externalAbort, {
+            once: true,
+        });
+        if (this.options.timeout != null)
+            this.deadline(this.options.timeout, "Overall transcription deadline expired");
+        this.worker = this.run();
+    }
+    fail(error) {
+        if (this.failure || this.finished)
+            return;
+        if (error.requestId === null && this.requestId !== null)
+            error = new error.constructor(error.message, this.requestId, { cause: error.cause });
+        this.failure = error;
+        this.queue.fail(error);
+        for (const timer of this.timers)
+            timer.dispose();
+        this.controller.abort(error);
+        this.call?.cancel();
+        this.options.signal?.removeEventListener("abort", this.externalAbort);
+        if (!this.worker || this.workerFinished) {
+            this.source = null;
+            this.owner.forget(this);
+        }
+    }
+    async produce() {
+        const signal = this.controller.signal;
+        await abortable(this.acceptance, signal);
+        const audio = new InputAudio(this.options.inputFormat);
+        let iterator;
+        try {
+            try {
+                iterator = this.source[Symbol.asyncIterator]();
+            }
+            catch (error) {
+                throw new RimeInputError("The audio source failed", this.requestId, {
+                    cause: error,
+                });
+            }
+            for (;;) {
+                let result;
+                try {
+                    result = await abortable(iterator.next(), signal);
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        throw signal.reason;
+                    throw new RimeInputError("The audio source failed", this.requestId, {
+                        cause: error,
+                    });
+                }
+                if (result.done)
+                    break;
+                for (const part of audio.feed(result.value))
+                    await this.call.writeAudio(part);
+            }
+            audio.finish();
+            this.inputDone = true;
+            this.completion = this.deadline(policy.completionTimeout, "Transcription completion timed out");
+            this.call.finishInput();
+        }
+        finally {
+            if (iterator?.return) {
+                const cleanup = scope([], policy.cleanupTimeout, new RimeTimeoutError("Audio source cleanup timed out"));
+                try {
+                    await abortable(Promise.resolve().then(() => iterator.return()), cleanup.signal);
+                }
+                catch {
+                    /* Caller-owned source cleanup cannot replace the operation outcome. */
+                }
+                finally {
+                    cleanup.dispose();
+                }
+            }
+        }
+    }
+    async read() {
+        const state = new TranscriptState(policy.transcriptBytes);
+        for await (const message of this.call.responses()) {
+            const update = state.accept(message, this.inputDone);
+            if (state.language !== null) {
+                this.admission?.dispose();
+                this.accepted();
+            }
+            if (update)
+                await this.queue.put(update);
+        }
+        return state.finish();
+    }
+    async run() {
+        let tasks = [];
+        try {
+            const prepared = await this.owner.prepare(this.controller.signal);
+            this.controller.signal.throwIfAborted();
+            this.call = new TranscriptionCall(prepared.client, prepared.metadata, this.controller.signal);
+            this.admission = this.deadline(policy.acceptanceTimeout, "Transcription acceptance timed out");
+            await this.call.start(this.options.language, this.options.mode ?? "written", this.options.contextTerms ?? []);
+            const producer = this.produce(), reader = this.read();
+            tasks = [producer, reader];
+            const [, final] = await Promise.all([producer, reader]);
+            this.completion?.dispose();
+            await this.queue.put(final);
+            this.queue.finish();
+        }
+        catch (error) {
+            this.fail(error instanceof RimeError
+                ? error
+                : new RimeStreamError("Transcription failed", this.requestId, {
+                    cause: error,
+                }));
+        }
+        finally {
+            if (this.failure)
+                this.controller.abort(this.failure);
+            this.call?.cancel();
+            await Promise.allSettled(tasks);
+            this.source = null;
+            this.workerFinished = true;
+            if (this.failure)
+                this.owner.forget(this);
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    async next() {
+        if (this.reading)
+            throw new RimeInputError("TranscriptStream permits only one concurrent reader");
+        this.reading = true;
+        try {
+            this.start();
+            if (this.finished)
+                return { done: true, value: undefined };
+            const result = await this.queue.get();
+            if (this.failure)
+                throw this.failure;
+            if (!result.done && result.value.kind === "final") {
+                await this.cleanup();
+                if (this.failure)
+                    throw this.failure;
+                this.finished = true;
+            }
+            return result;
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async cleanup() {
+        await this.worker;
+        for (const timer of this.timers)
+            timer.dispose();
+        this.options.signal?.removeEventListener("abort", this.externalAbort);
+        this.owner.forget(this);
+    }
+    /** Cancel unfinished work and release owned resources; safe to repeat. */
+    async cancel() {
+        this.fail(new RimeCancelledError("Transcription cancelled"));
+        await this.cleanup();
+        this.source = null;
+    }
+    async return() {
+        await this.cancel();
+        return { done: true, value: undefined };
+    }
+    async [Symbol.asyncDispose]() {
+        await this.cancel();
+    }
+}

package/dist/stt/transport.d.ts

@@ -0,0 +1,13 @@
+import * as grpc from "@grpc/grpc-js";
+import * as schema from "@rimelabs/api";
+import { BidiCall } from "../grpc.js";
+import type { TranscriptionMode } from "./types.js";
+export declare function requireSchema(): void;
+export declare const transport: {
+    makeClient: (target: string) => grpc.Client;
+};
+export declare class TranscriptionCall extends BidiCall<schema.StreamingTranscriptionRequest, schema.StreamingTranscriptionResponse> {
+    constructor(client: grpc.Client, auth: grpc.Metadata, signal: AbortSignal);
+    start(language: string, mode: TranscriptionMode, contextTerms: readonly string[]): Promise<void>;
+    writeAudio(audio: Uint8Array): Promise<void>;
+}

package/dist/stt/transport.js

@@ -0,0 +1,45 @@
+import * as grpc from "@grpc/grpc-js";
+import { create } from "@bufbuild/protobuf";
+import * as schema from "@rimelabs/api";
+import { BidiCall, serializer, deserializer } from "../grpc.js";
+import { RimeInputError } from "../errors.js";
+import { policy } from "./policy.js";
+export function requireSchema() {
+    if (!schema.SpeechToText)
+        throw new RimeInputError("STT requires @rimelabs/api with SpeechToText definitions");
+}
+export const transport = {
+    makeClient: (target) => new grpc.Client(target, grpc.credentials.createSsl(), {
+        "grpc.enable_retries": 0,
+        "grpc.max_receive_message_length": policy.receiveBytes,
+        "grpc.max_send_message_length": 131072,
+    }),
+};
+export class TranscriptionCall extends BidiCall {
+    constructor(client, auth, signal) {
+        requireSchema();
+        const service = schema.SpeechToText;
+        const method = service.method.transcribeStreaming;
+        super(client.makeBidiStreamRequest(`/${service.typeName}/${method.name}`, serializer(method.input), deserializer(method.output), auth), signal);
+    }
+    start(language, mode, contextTerms) {
+        return this.write(create(schema.StreamingTranscriptionRequestSchema, {
+            payload: {
+                case: "config",
+                value: {
+                    language,
+                    mode: mode === "verbatim"
+                        ? schema.TranscriptionMode.VERBATIM
+                        : schema.TranscriptionMode.WRITTEN,
+                    contextTerms: [...contextTerms],
+                    outputContract: schema.StreamingOutputContract.REVISED_HYPOTHESES,
+                },
+            },
+        }));
+    }
+    writeAudio(audio) {
+        return this.write(create(schema.StreamingTranscriptionRequestSchema, {
+            payload: { case: "audio", value: audio },
+        }));
+    }
+}

package/dist/stt/types.d.ts

@@ -0,0 +1,34 @@
+import type { PCMFormat } from "../pcm.js";
+/** Formatting intent, for example "flight 247" or "flight two four seven". */
+export type TranscriptionMode = "written" | "verbatim";
+/** One caller-ended utterance of headerless signed PCM16 little-endian audio. */
+export type AudioSource = AsyncIterable<Uint8Array>;
+export interface TranscriptionOptions {
+    /** Required BCP-47 tag, passed unchanged to the service (for example "en"). */
+    language: string;
+    /** Formatting intent; defaults to written and does not guarantee exact tokens. */
+    mode?: TranscriptionMode;
+    /** Recognition hints passed unchanged and in order, for example ["Super-G"]. */
+    contextTerms?: readonly string[];
+    /** Defaults to PCM16 little-endian mono 16 kHz; fixed for the utterance. */
+    inputFormat?: PCMFormat;
+    /** Optional overall deadline in seconds, including source and consumer pauses. */
+    timeout?: number | null;
+    /** Cancels only this utterance, including a pending connection. */
+    signal?: AbortSignal;
+}
+export interface TranscriptionPartial {
+    /** A revisable replacement snapshot. */
+    readonly kind: "partial";
+    /** Complete current text; replace previous text instead of appending it. */
+    readonly text: string;
+}
+export interface TranscriptionFinal {
+    /** Successful protocol and transport completion. */
+    readonly kind: "final";
+    /** Complete final text; silence can produce an empty string. */
+    readonly text: string;
+    /** Canonical BCP-47 tag selected by the service, for example "en". */
+    readonly language: string;
+}
+export type TranscriptionUpdate = TranscriptionPartial | TranscriptionFinal;

package/dist/stt/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{audio.js → tts/audio.js}

@@ -1,4 +1,4 @@
-import { RimeAudioFormatError } from "./errors.js";
+import { RimeAudioFormatError } from "../errors.js";
 export class AudioFormat {
     encoding;
     sampleRate;
@@ -20,7 +20,8 @@ const total = raw.reduce((a, b) => a + b, 0);
 const coefficients = raw.map((x) => x / total);
 function mulaw(sample) {
     sample = Math.max(-32768, Math.min(32767, sample));
-    const sign = sample < 0 ? 128 : 0, magnitude = Math.min(Math.abs(sample), 32635) + 132;
+    // G.711 uses one's complement for negative PCM before quantization.
+    const sign = sample < 0 ? 128 : 0, magnitude = Math.min(sample < 0 ? ~sample : sample, 32635) + 132;
     const exponent = Math.max(0, Math.floor(Math.log2(magnitude)) - 7);
     return ~(sign | (exponent << 4) | ((magnitude >> (exponent + 3)) & 15)) & 255;
 }

package/dist/tts/client.d.ts

@@ -0,0 +1,39 @@
+import { AudioFormat } from "./audio.js";
+import { AudioStream, type TextSource } from "./stream.js";
+import { Credentials } from "../auth.js";
+import { policy } from "./policy.js";
+export interface SynthesisOptions {
+    voice?: string | null;
+    language?: string;
+    audioFormat?: AudioFormat | null;
+    timeout?: number | null;
+}
+export interface DiscoveryOptions {
+    timeout?: number | null;
+}
+export interface VoiceListOptions extends DiscoveryOptions {
+    language?: string | null;
+}
+export declare class TTS {
+    private readonly credentials;
+    private readonly deployment;
+    private readonly defaultTimeout;
+    private readonly checkOpen;
+    private client;
+    private streams;
+    private discoveryOperations;
+    readonly voices: {
+        list: (options?: VoiceListOptions) => Promise<string[]>;
+    };
+    readonly languages: {
+        list: (options?: DiscoveryOptions) => Promise<string[]>;
+    };
+    constructor(credentials: Credentials, deployment: Readonly<typeof policy>, defaultTimeout: number | null, checkOpen: () => void);
+    private prepare;
+    /** Synthesize complete text and return an audio stream. Do not await this call. */
+    synthesize(text: string, options?: SynthesisOptions): AudioStream;
+    /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
+    stream(text: TextSource, options?: SynthesisOptions): AudioStream;
+    private discover;
+    close(): Promise<void>;
+}

package/dist/tts/client.js

@@ -0,0 +1,121 @@
+import { AudioFormat } from "./audio.js";
+import { AudioStream, constructionKey } from "./stream.js";
+import { policy, timeout, nonempty } from "./policy.js";
+import { abortable } from "../cancellation.js";
+import { transport, connect, metadata, discover, } from "./transport.js";
+import { RimeInputError, RimeAudioFormatError, RimeCancelledError, RimeTimeoutError, RimeUnavailableError, } from "../errors.js";
+export class TTS {
+    credentials;
+    deployment;
+    defaultTimeout;
+    checkOpen;
+    client = null;
+    streams = new Set();
+    discoveryOperations = new Map();
+    voices;
+    languages;
+    constructor(credentials, deployment, defaultTimeout, checkOpen) {
+        this.credentials = credentials;
+        this.deployment = deployment;
+        this.defaultTimeout = defaultTimeout;
+        this.checkOpen = checkOpen;
+        this.voices = {
+            list: async (options = {}) => {
+                if (options.language !== undefined && options.language !== null)
+                    nonempty(options.language, "language");
+                return this.discover("voices", options.language, options.timeout);
+            },
+        };
+        this.languages = {
+            list: (options = {}) => this.discover("languages", undefined, options.timeout),
+        };
+    }
+    async prepare(signal) {
+        this.checkOpen();
+        const auth = await this.credentials.metadata(signal);
+        this.checkOpen();
+        this.client ??= transport.makeClient(this.deployment.target);
+        await connect(this.client, signal);
+        return { client: this.client, metadata: metadata(auth) };
+    }
+    /** Synthesize complete text and return an audio stream. Do not await this call. */
+    synthesize(text, options = {}) {
+        this.checkOpen();
+        if (typeof text !== "string")
+            throw new RimeInputError("text must be a string; use stream() for an async text source");
+        if (!text.trim())
+            throw new RimeInputError("Text must contain non-whitespace characters");
+        return this.stream((async function* () {
+            yield text;
+        })(), options);
+    }
+    /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
+    stream(text, options = {}) {
+        this.checkOpen();
+        if (typeof text === "string" ||
+            !text ||
+            typeof text[Symbol.asyncIterator] !== "function")
+            throw new RimeInputError("text must be an async iterable of strings; use synthesize() for a string");
+        const voice = options.voice === undefined || options.voice === null
+            ? this.deployment.defaultVoice
+            : nonempty(options.voice, "voice");
+        const language = nonempty(options.language ?? "en", "language");
+        const format = options.audioFormat ?? AudioFormat.PCM_24000;
+        if (format !== AudioFormat.PCM_24000 && format !== AudioFormat.MULAW_8000)
+            throw new RimeAudioFormatError("Select a named AudioFormat profile");
+        const audio = new AudioStream(constructionKey, {
+            prepare: (s) => this.prepare(s),
+            checkOpen: () => this.checkOpen(),
+            forget: (s) => this.streams.delete(s),
+        }, text, voice, language, format, timeout(options.timeout, this.defaultTimeout));
+        this.streams.add(audio);
+        return audio;
+    }
+    async discover(kind, language, override) {
+        this.checkOpen();
+        const budget = Math.min(timeout(override, this.defaultTimeout) ?? Infinity, policy.discoveryTimeout);
+        const controller = new AbortController();
+        let requestId = null;
+        const timer = setTimeout(() => controller.abort(new RimeTimeoutError("Discovery deadline expired")), budget * 1000);
+        const operation = (async () => {
+            try {
+                const prepared = await this.prepare(controller.signal);
+                for (let attempt = 0;; attempt++) {
+                    requestId = null;
+                    try {
+                        return await discover(prepared, kind, language, controller.signal);
+                    }
+                    catch (error) {
+                        if (!(error instanceof RimeUnavailableError) || attempt === 2)
+                            throw error;
+                        requestId = error.requestId;
+                        await abortable(new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt)), controller.signal);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof RimeTimeoutError && requestId !== null)
+                    throw new RimeTimeoutError(error.message, requestId, {
+                        cause: error.cause,
+                    });
+                throw error;
+            }
+            finally {
+                clearTimeout(timer);
+                this.discoveryOperations.delete(controller);
+            }
+        })();
+        this.discoveryOperations.set(controller, operation);
+        return operation;
+    }
+    async close() {
+        const discoveries = [...this.discoveryOperations.values()];
+        for (const controller of this.discoveryOperations.keys())
+            controller.abort(new RimeCancelledError("Client closed during discovery"));
+        await Promise.all([
+            ...[...this.streams].map((stream) => stream.cancel()),
+            Promise.allSettled(discoveries),
+        ]);
+        this.client?.close();
+    }
+}

package/dist/{policy.d.ts → tts/policy.d.ts}

@@ -1,6 +1,8 @@
+export { timeout } from "../validation.js";
 export declare const policy: {
     target: string;
     audience: string;
+    defaultVoice: string;
     exchangeUrl: string;
     sentenceBytes: number;
     sourceChars: number;
@@ -15,6 +17,4 @@ export declare const policy: {
     cleanupTimeout: number;
 };
 export declare function resolve(model: string, endpoint?: string | null): Readonly<typeof policy>;
-export declare function timeout(value: unknown, inherited?: number | null): number | null;
 export declare function nonempty(value: unknown, name: string): string;
-export declare function abortable<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/dist/tts/policy.js

@@ -0,0 +1,41 @@
+import { endpointAddress } from "../validation.js";
+export { timeout } from "../validation.js";
+import { RimeInputError } from "../errors.js";
+const codaHostname = "coda.api.rime.ai";
+export const policy = {
+    target: `${codaHostname}:443`,
+    audience: codaHostname,
+    defaultVoice: "clementine",
+    exchangeUrl: "https://themis.api.rime.ai/v1/token",
+    sentenceBytes: 65536,
+    sourceChars: 1024,
+    outputBytes: 96000,
+    outputChunkBytes: 9600,
+    receiveBytes: 4194304,
+    authTimeout: 10,
+    connectionTimeout: 10,
+    firstAudioTimeout: 30,
+    progressTimeout: 60,
+    discoveryTimeout: 10,
+    cleanupTimeout: 2,
+};
+export function resolve(model, endpoint) {
+    const deployment = { ...policy };
+    if (model === "mistv3") {
+        const hostname = "mist.api.rime.ai";
+        deployment.target = `${hostname}:443`;
+        deployment.audience = hostname;
+        deployment.defaultVoice = "astra";
+    }
+    else if (model !== "coda") {
+        throw new RimeInputError("model must be 'coda' or 'mistv3'");
+    }
+    if (endpoint === undefined || endpoint === null)
+        return deployment;
+    return { ...deployment, ...endpointAddress(endpoint) };
+}
+export function nonempty(value, name) {
+    if (typeof value !== "string" || !value.trim())
+        throw new RimeInputError(`${name} must be a non-empty string`);
+    return value;
+}

package/dist/{sentences.js → tts/sentences.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
-import { RimeInputError, RimeResourceLimitError } from "./errors.js";
+import { RimeInputError, RimeResourceLimitError } from "../errors.js";
 const require = createRequire(import.meta.url);
-const module = require("../vendor/blingfire.cjs");
+const module = require("../../vendor/blingfire.cjs");
 export const ready = module.ready;
 // These marks schedule scans. Only BlingFire decides sentence boundaries.
 // Keep the set and code-point counts in sync with Python's _sentences.py.

package/dist/{stream.d.ts → tts/stream.d.ts}

@@ -5,7 +5,7 @@ export interface StreamOwner {
     checkOpen(): void;
     forget(stream: AudioStream): void;
 }
-export type TextSource = string | AsyncIterable<string>;
+export type TextSource = AsyncIterable<string>;
 export declare const constructionKey: unique symbol;
 export declare class AudioStream implements AsyncIterableIterator<Uint8Array> {
     private owner;

package/dist/{stream.js → tts/stream.js}

@@ -2,11 +2,12 @@ import { randomUUID } from "node:crypto";
 import { debuglog } from "node:util";
 const log = debuglog("rime-sdk");
 import { Converter } from "./audio.js";
-import { policy, abortable } from "./policy.js";
+import { policy } from "./policy.js";
+import { abortable } from "../cancellation.js";
 import { ByteQueue } from "./queue.js";
 import { SentenceBuffer, ready } from "./sentences.js";
 import { SynthesisCall } from "./transport.js";
-import { RimeError, RimeInputError, RimeCancelledError, RimeTimeoutError, RimeStreamError, } from "./errors.js";
+import { RimeError, RimeInputError, RimeCancelledError, RimeTimeoutError, RimeStreamError, } from "../errors.js";
 export const constructionKey = Symbol("private stream constructor");
 export class AudioStream {
     owner;
@@ -40,7 +41,7 @@ export class AudioStream {
         this.formatValue = formatValue;
         this.timeout = timeout;
         if (key !== constructionKey)
-            throw new TypeError("AudioStream is returned by client.tts.stream()");
+            throw new TypeError("AudioStream is returned by client.tts.synthesize() or client.tts.stream()");
     }
     get format() {
         return this.formatValue;
@@ -99,11 +100,7 @@ export class AudioStream {
         let meaningful = false;
         try {
             try {
-                iterator = (typeof source === "string"
-                    ? (async function* () {
-                        yield source;
-                    })()
-                    : source)[Symbol.asyncIterator]();
+                iterator = source[Symbol.asyncIterator]();
             }
             catch (error) {
                 if (this.controller.signal.aborted)

package/dist/{transport.d.ts → tts/transport.d.ts}

@@ -1,31 +1,23 @@
+export { metadata } from "../grpc.js";
+export { rpcError } from "../grpc.js";
 import * as grpc from "@grpc/grpc-js";
-import * as errors from "./errors.js";
 export type Connection = grpc.Client;
 export interface PreparedConnection {
     client: Connection;
     metadata: grpc.Metadata;
 }
 export type DiscoveryKind = "voices" | "languages";
-export declare function rpcError(code: number, requestId?: string | null): errors.RimeError;
 export declare const transport: {
     makeClient: (target: string) => grpc.Client;
 };
 export declare function connect(client: grpc.Client, signal: AbortSignal): Promise<void>;
-export declare function metadata(value: string): grpc.Metadata;
 export declare function discover(prepared: PreparedConnection, kind: DiscoveryKind, language: string | null | undefined, signal: AbortSignal): Promise<string[]>;
 export declare class SynthesisCall {
-    private signal;
-    private readonly call;
-    private readonly metadataPromise;
-    private readonly statusPromise;
-    private status;
-    private id;
+    private readonly rpc;
     constructor(prepared: PreparedConnection, signal: AbortSignal);
     get requestId(): string | null;
     get done(): boolean;
     cancel(): void;
-    private error;
-    private writeMessage;
     start(voice: string, language: string): Promise<void>;
     write(sentence: string): Promise<void>;
     finishInput(): void;