@livekit/agents 0.7.6 → 0.7.7

package/dist/metrics/utils.d.cts

@@ -0,0 +1,10 @@
+import type { AgentMetrics, LLMMetrics, PipelineEOUMetrics, PipelineLLMMetrics, PipelineTTSMetrics, STTMetrics, TTSMetrics, VADMetrics } from './base.js';
+export declare const logMetrics: (metrics: AgentMetrics) => void;
+export declare const isLLMMetrics: (metrics: AgentMetrics) => metrics is LLMMetrics;
+export declare const isPipelineLLMMetrics: (metrics: AgentMetrics) => metrics is PipelineLLMMetrics;
+export declare const isVADMetrics: (metrics: AgentMetrics) => metrics is VADMetrics;
+export declare const isPipelineEOUMetrics: (metrics: AgentMetrics) => metrics is PipelineEOUMetrics;
+export declare const isTTSMetrics: (metrics: AgentMetrics) => metrics is TTSMetrics;
+export declare const isPipelineTTSMetrics: (metrics: AgentMetrics) => metrics is PipelineTTSMetrics;
+export declare const isSTTMetrics: (metrics: AgentMetrics) => metrics is STTMetrics;
+//# sourceMappingURL=utils.d.ts.map

package/dist/multimodal/agent_playout.d.cts

@@ -0,0 +1,34 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { AudioFrame } from '@livekit/rtc-node';
+import { type AudioSource } from '@livekit/rtc-node';
+import { EventEmitter } from 'node:events';
+import type { TextAudioSynchronizer } from '../transcription.js';
+import { type AsyncIterableQueue, Future } from '../utils.js';
+export declare const proto: {};
+export declare class PlayoutHandle extends EventEmitter {
+    #private;
+    /** @internal */
+    synchronizer: TextAudioSynchronizer;
+    /** @internal */
+    doneFut: Future;
+    /** @internal */
+    intFut: Future;
+    /** @internal */
+    pushedDuration: number;
+    /** @internal */
+    totalPlayedTime: number | undefined;
+    constructor(audioSource: AudioSource, sampleRate: number, itemId: string, contentIndex: number, synchronizer: TextAudioSynchronizer);
+    get itemId(): string;
+    get audioSamples(): number;
+    get textChars(): number;
+    get contentIndex(): number;
+    get interrupted(): boolean;
+    get done(): boolean;
+    interrupt(): void;
+}
+export declare class AgentPlayout extends EventEmitter {
+    #private;
+    constructor(audioSource: AudioSource, sampleRate: number, numChannels: number, inFrameSize: number, outFrameSize: number);
+    play(itemId: string, contentIndex: number, synchronizer: TextAudioSynchronizer, textStream: AsyncIterableQueue<string>, audioStream: AsyncIterableQueue<AudioFrame>): PlayoutHandle;
+}
+//# sourceMappingURL=agent_playout.d.ts.map

package/dist/multimodal/index.d.cts

@@ -0,0 +1,3 @@
+export * from './multimodal_agent.js';
+export * from './agent_playout.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/multimodal/multimodal_agent.d.cts

@@ -0,0 +1,48 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { NoiseCancellationOptions, RemoteAudioTrack, RemoteParticipant, Room } from '@livekit/rtc-node';
+import { EventEmitter } from 'node:events';
+import * as llm from '../llm/index.js';
+/**
+ * @internal
+ * @beta
+ */
+export declare abstract class RealtimeSession extends EventEmitter {
+    abstract conversation: any;
+    abstract inputAudioBuffer: any;
+    abstract fncCtx: llm.FunctionContext | undefined;
+    abstract recoverFromTextResponse(itemId: string): void;
+}
+/**
+ * @internal
+ * @beta
+ */
+export declare abstract class RealtimeModel {
+    abstract session(options: any): RealtimeSession;
+    abstract close(): Promise<void>;
+    abstract sampleRate: number;
+    abstract numChannels: number;
+    abstract inFrameSize: number;
+    abstract outFrameSize: number;
+}
+export type AgentState = 'initializing' | 'thinking' | 'listening' | 'speaking';
+export declare const AGENT_STATE_ATTRIBUTE = "lk.agent.state";
+/** @beta */
+export declare class MultimodalAgent extends EventEmitter {
+    #private;
+    model: RealtimeModel;
+    room: Room | null;
+    linkedParticipant: RemoteParticipant | null;
+    subscribedTrack: RemoteAudioTrack | null;
+    readMicroTask: Promise<void> | null;
+    constructor({ model, chatCtx, fncCtx, maxTextResponseRetries, noiseCancellation, }: {
+        model: RealtimeModel;
+        chatCtx?: llm.ChatContext;
+        fncCtx?: llm.FunctionContext;
+        maxTextResponseRetries?: number;
+        noiseCancellation?: NoiseCancellationOptions;
+    });
+    get fncCtx(): llm.FunctionContext | undefined;
+    set fncCtx(ctx: llm.FunctionContext | undefined);
+    start(room: Room, participant?: RemoteParticipant | string | null): Promise<RealtimeSession>;
+}
+//# sourceMappingURL=multimodal_agent.d.ts.map

package/dist/pipeline/agent_output.d.cts

@@ -0,0 +1,33 @@
+import type { AudioFrame } from '@livekit/rtc-node';
+import type { TextAudioSynchronizer } from '../transcription.js';
+import { type TTS } from '../tts/index.js';
+import { AsyncIterableQueue, Future } from '../utils.js';
+import type { AgentPlayout, PlayoutHandle } from './agent_playout.js';
+export type SpeechSource = AsyncIterable<string> | string | Promise<string>;
+export declare class SynthesisHandle {
+    #private;
+    static readonly FLUSH_SENTINEL: unique symbol;
+    text?: string;
+    ttsSource: SpeechSource;
+    tts: TTS;
+    queue: AsyncIterableQueue<AudioFrame | typeof SynthesisHandle.FLUSH_SENTINEL>;
+    intFut: Future;
+    synchronizer: TextAudioSynchronizer;
+    constructor(speechId: string, ttsSource: SpeechSource, agentPlayout: AgentPlayout, tts: TTS, synchronizer: TextAudioSynchronizer);
+    get speechId(): string;
+    get validated(): boolean;
+    get interrupted(): boolean;
+    get playHandle(): PlayoutHandle | undefined;
+    /** Validate the speech for playout. */
+    play(): PlayoutHandle;
+    /** Interrupt the speech. */
+    interrupt(): void;
+}
+export declare class AgentOutput {
+    #private;
+    constructor(agentPlayout: AgentPlayout, tts: TTS);
+    get playout(): AgentPlayout;
+    close(): Promise<void>;
+    synthesize(speechId: string, ttsSource: SpeechSource, synchronizer: TextAudioSynchronizer): SynthesisHandle;
+}
+//# sourceMappingURL=agent_output.d.ts.map

package/dist/pipeline/agent_playout.d.cts

@@ -0,0 +1,40 @@
+import type { AudioFrame, AudioSource } from '@livekit/rtc-node';
+import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+import type { TextAudioSynchronizer } from '../transcription.js';
+import { Future } from '../utils.js';
+import { SynthesisHandle } from './agent_output.js';
+export declare enum AgentPlayoutEvent {
+    PLAYOUT_STARTED = 0,
+    PLAYOUT_STOPPED = 1
+}
+export type AgentPlayoutCallbacks = {
+    [AgentPlayoutEvent.PLAYOUT_STARTED]: () => void;
+    [AgentPlayoutEvent.PLAYOUT_STOPPED]: (interrupt: boolean) => void;
+};
+export declare class PlayoutHandle {
+    #private;
+    playoutSource: AsyncIterable<AudioFrame | typeof SynthesisHandle.FLUSH_SENTINEL>;
+    totalPlayedTime?: number;
+    synchronizer: TextAudioSynchronizer;
+    pushedDuration: number;
+    intFut: Future;
+    doneFut: Future;
+    constructor(speechId: string, audioSource: AudioSource, playoutSource: AsyncIterable<AudioFrame | typeof SynthesisHandle.FLUSH_SENTINEL>, synchronizer: TextAudioSynchronizer);
+    get speechId(): string;
+    get interrupted(): boolean;
+    get timePlayed(): number;
+    get done(): boolean;
+    interrupt(): void;
+    join(): Future;
+}
+declare const AgentPlayout_base: new () => TypedEmitter<AgentPlayoutCallbacks>;
+export declare class AgentPlayout extends AgentPlayout_base {
+    #private;
+    constructor(audioSource: AudioSource);
+    get targetVolume(): number;
+    set targetVolume(vol: number);
+    play(speechId: string, playoutSource: AsyncIterable<AudioFrame | typeof SynthesisHandle.FLUSH_SENTINEL>, synchronizer: TextAudioSynchronizer): PlayoutHandle;
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=agent_playout.d.ts.map

package/dist/pipeline/human_input.d.cts

@@ -0,0 +1,30 @@
+import type { NoiseCancellationOptions, RemoteAudioTrack, RemoteParticipant, Room } from '@livekit/rtc-node';
+import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+import type { STT, SpeechEvent } from '../stt/stt.js';
+import type { VAD, VADEvent } from '../vad.js';
+export declare enum HumanInputEvent {
+    START_OF_SPEECH = 0,
+    VAD_INFERENCE_DONE = 1,
+    END_OF_SPEECH = 2,
+    FINAL_TRANSCRIPT = 3,
+    INTERIM_TRANSCRIPT = 4
+}
+export type HumanInputCallbacks = {
+    [HumanInputEvent.START_OF_SPEECH]: (event: VADEvent) => void;
+    [HumanInputEvent.VAD_INFERENCE_DONE]: (event: VADEvent) => void;
+    [HumanInputEvent.END_OF_SPEECH]: (event: VADEvent) => void;
+    [HumanInputEvent.FINAL_TRANSCRIPT]: (event: SpeechEvent) => void;
+    [HumanInputEvent.INTERIM_TRANSCRIPT]: (event: SpeechEvent) => void;
+};
+declare const HumanInput_base: new () => TypedEmitter<HumanInputCallbacks>;
+export declare class HumanInput extends HumanInput_base {
+    #private;
+    constructor(room: Room, vad: VAD, stt: STT, participant: RemoteParticipant, noiseCancellation?: NoiseCancellationOptions);
+    get participant(): RemoteParticipant;
+    get subscribedTrack(): RemoteAudioTrack | undefined;
+    get speaking(): boolean;
+    get speakingProbability(): number;
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=human_input.d.ts.map

package/dist/pipeline/index.d.cts

@@ -0,0 +1,2 @@
+export { type AgentState, type BeforeTTSCallback, type BeforeLLMCallback, type VPACallbacks, type AgentTranscriptionOptions, type VPAOptions, VPAEvent, VoicePipelineAgent, AgentCallContext, } from './pipeline_agent.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pipeline/pipeline_agent.d.cts

@@ -0,0 +1,151 @@
+import type { NoiseCancellationOptions, RemoteParticipant, Room } from '@livekit/rtc-node';
+import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+import type { CallableFunctionResult, FunctionCallInfo, FunctionContext, LLM } from '../llm/index.js';
+import { LLMStream } from '../llm/index.js';
+import { ChatContext, ChatMessage } from '../llm/index.js';
+import type { AgentMetrics } from '../metrics/base.js';
+import { type STT } from '../stt/index.js';
+import type { SentenceTokenizer, WordTokenizer } from '../tokenize/tokenizer.js';
+import type { TTS } from '../tts/index.js';
+import { type VAD } from '../vad.js';
+import type { SpeechSource } from './agent_output.js';
+import { SpeechHandle } from './speech_handle.js';
+export type AgentState = 'initializing' | 'thinking' | 'listening' | 'speaking';
+export declare const AGENT_STATE_ATTRIBUTE = "lk.agent.state";
+export type BeforeLLMCallback = (agent: VoicePipelineAgent, chatCtx: ChatContext) => LLMStream | false | void | Promise<LLMStream | false | void>;
+export type BeforeTTSCallback = (agent: VoicePipelineAgent, source: string | AsyncIterable<string>) => SpeechSource;
+export declare enum VPAEvent {
+    USER_STARTED_SPEAKING = 0,
+    USER_STOPPED_SPEAKING = 1,
+    AGENT_STARTED_SPEAKING = 2,
+    AGENT_STOPPED_SPEAKING = 3,
+    USER_SPEECH_COMMITTED = 4,
+    AGENT_SPEECH_COMMITTED = 5,
+    AGENT_SPEECH_INTERRUPTED = 6,
+    FUNCTION_CALLS_COLLECTED = 7,
+    FUNCTION_CALLS_FINISHED = 8,
+    METRICS_COLLECTED = 9
+}
+export type VPACallbacks = {
+    [VPAEvent.USER_STARTED_SPEAKING]: () => void;
+    [VPAEvent.USER_STOPPED_SPEAKING]: () => void;
+    [VPAEvent.AGENT_STARTED_SPEAKING]: () => void;
+    [VPAEvent.AGENT_STOPPED_SPEAKING]: () => void;
+    [VPAEvent.USER_SPEECH_COMMITTED]: (msg: ChatMessage) => void;
+    [VPAEvent.AGENT_SPEECH_COMMITTED]: (msg: ChatMessage) => void;
+    [VPAEvent.AGENT_SPEECH_INTERRUPTED]: (msg: ChatMessage) => void;
+    [VPAEvent.FUNCTION_CALLS_COLLECTED]: (funcs: FunctionCallInfo[]) => void;
+    [VPAEvent.FUNCTION_CALLS_FINISHED]: (funcs: CallableFunctionResult[]) => void;
+    [VPAEvent.METRICS_COLLECTED]: (metrics: AgentMetrics) => void;
+};
+interface TurnDetector {
+    unlikelyThreshold: number;
+    supportsLanguage: (language?: string) => boolean;
+    predictEndOfTurn: (chatCtx: ChatContext) => Promise<number>;
+}
+export declare class AgentCallContext {
+    #private;
+    constructor(agent: VoicePipelineAgent, llmStream: LLMStream);
+    static getCurrent(): AgentCallContext;
+    get agent(): VoicePipelineAgent;
+    storeMetadata(key: string, value: any): void;
+    getMetadata(key: string, orDefault?: any): any;
+    get llmStream(): LLMStream;
+    get extraChatMessages(): ChatMessage[];
+    addExtraChatMessage(message: ChatMessage): void;
+}
+export interface AgentTranscriptionOptions {
+    /** Whether to forward the user transcription to the client */
+    userTranscription: boolean;
+    /** Whether to forward the agent transcription to the client */
+    agentTranscription: boolean;
+    /**
+     * The speed at which the agent's speech transcription is forwarded to the client.
+     * We try to mimic the agent's speech speed by adjusting the transcription speed.
+     */
+    agentTranscriptionSpeech: number;
+    /**
+     * The tokenizer used to split the speech into sentences.
+     * This is used to decide when to mark a transcript as final for the agent transcription.
+     */
+    sentenceTokenizer: SentenceTokenizer;
+    /**
+     * The tokenizer used to split the speech into words.
+     * This is used to simulate the "interim results" of the agent transcription.
+     */
+    wordTokenizer: WordTokenizer;
+    /**
+     * A function that takes a string (word) as input and returns a list of strings,
+     * representing the hyphenated parts of the word.
+     */
+    hyphenateWord: (word: string) => string[];
+}
+export interface VPAOptions {
+    /** Chat context for the assistant. */
+    chatCtx?: ChatContext;
+    /** Function context for the assistant. */
+    fncCtx?: FunctionContext;
+    /** Whether to allow the user to interrupt the assistant. */
+    allowInterruptions: boolean;
+    /** Minimum duration of speech to consider for interruption. */
+    interruptSpeechDuration: number;
+    /** Minimum number of words to consider for interuption. This may increase latency. */
+    interruptMinWords: number;
+    /** Delay to wait before considering the user speech done. */
+    minEndpointingDelay: number;
+    maxNestedFncCalls: number;
+    preemptiveSynthesis: boolean;
+    beforeLLMCallback: BeforeLLMCallback;
+    beforeTTSCallback: BeforeTTSCallback;
+    /** Options for assistant transcription. */
+    transcription: AgentTranscriptionOptions;
+    /** Turn detection model to use. */
+    turnDetector?: TurnDetector;
+    /** Noise cancellation options. */
+    noiseCancellation?: NoiseCancellationOptions;
+}
+declare const VoicePipelineAgent_base: new () => TypedEmitter<VPACallbacks>;
+/** A pipeline agent (VAD + STT + LLM + TTS) implementation. */
+export declare class VoicePipelineAgent extends VoicePipelineAgent_base {
+    #private;
+    /** Minimum time played for the user speech to be committed to the chat context. */
+    readonly MIN_TIME_PLAYED_FOR_COMMIT = 1.5;
+    protected static readonly FLUSH_SENTINEL: unique symbol;
+    transcribedText: string;
+    constructor(
+    /** Voice Activity Detection instance. */
+    vad: VAD, 
+    /** Speech-to-Text instance. */
+    stt: STT, 
+    /** Large Language Model instance. */
+    llm: LLM, 
+    /** Text-to-Speech instance. */
+    tts: TTS, 
+    /** Additional VoicePipelineAgent options. */
+    opts?: Partial<VPAOptions>);
+    get fncCtx(): FunctionContext | undefined;
+    set fncCtx(ctx: FunctionContext);
+    get chatCtx(): ChatContext;
+    get llm(): LLM;
+    get tts(): TTS;
+    get stt(): STT;
+    get vad(): VAD;
+    /** Start the voice assistant. */
+    start(
+    /** The room to connect to. */
+    room: Room, 
+    /**
+     * The participant to listen to.
+     *
+     * @remarks
+     * Can be a participant or an identity.
+     * If omitted, the first participant in the room will be selected.
+     */
+    participant?: RemoteParticipant | string | null): void;
+    /** Play a speech source through the voice assistant. */
+    say(source: string | LLMStream | AsyncIterable<string>, allowInterruptions?: boolean, addToChatCtx?: boolean): Promise<SpeechHandle>;
+    /** Close the voice assistant. */
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=pipeline_agent.d.ts.map

package/dist/pipeline/speech_handle.d.cts

@@ -0,0 +1,37 @@
+import type { ChatMessage, LLMStream } from '../llm/index.js';
+import type { SynthesisHandle } from './agent_output.js';
+export declare class SpeechHandle {
+    #private;
+    constructor(id: string, allowInterruptions: boolean, addToChatCtx: boolean, isReply: boolean, userQuestion: string, fncNestedDepth?: number, extraToolsMessages?: ChatMessage[] | undefined);
+    static createAssistantReply(allowInterruptions: boolean, addToChatCtx: boolean, userQuestion: string): SpeechHandle;
+    static createAssistantSpeech(allowInterruptions: boolean, addToChatCtx: boolean): SpeechHandle;
+    static createToolSpeech(allowInterruptions: boolean, addToChatCtx: boolean, fncNestedDepth: number, extraToolsMessages: ChatMessage[]): SpeechHandle;
+    waitForInitialization(): Promise<void>;
+    initialize(source: string | LLMStream | AsyncIterable<string>, synthesisHandle: SynthesisHandle): void;
+    markUserCommitted(): void;
+    markSpeechCommitted(): void;
+    get userCommitted(): boolean;
+    get speechCommitted(): boolean;
+    get id(): string;
+    get allowInterruptions(): boolean;
+    get addToChatCtx(): boolean;
+    get source(): string | LLMStream | AsyncIterable<string>;
+    get synthesisHandle(): SynthesisHandle;
+    set synthesisHandle(handle: SynthesisHandle);
+    get initialized(): boolean;
+    get isReply(): boolean;
+    get userQuestion(): string;
+    get interrupted(): boolean;
+    get fncNestedDepth(): number;
+    get extraToolsMessages(): ChatMessage[] | undefined;
+    addNestedSpeech(handle: SpeechHandle): void;
+    get nestedSpeechHandles(): SpeechHandle[];
+    nestedSpeechChanged(): Promise<void>;
+    get nestedSpeechFinished(): boolean;
+    markNestedSpeechFinished(): void;
+    join(): Promise<void>;
+    setDone(): void;
+    interrupt(): void;
+    cancel(): void;
+}
+//# sourceMappingURL=speech_handle.d.ts.map

package/dist/plugin.d.cts

@@ -0,0 +1,10 @@
+export declare abstract class Plugin {
+    #private;
+    registeredPlugins: Plugin[];
+    constructor(title: string, version: string);
+    static registerPlugins(plugin: Plugin): void;
+    abstract downloadFiles(): void;
+    get title(): string;
+    get version(): string;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/stt/index.d.cts

@@ -0,0 +1,3 @@
+export { type SpeechEvent, type SpeechData, type STTCapabilities, type RecognitionUsage, type STTCallbacks, SpeechEventType, STT, SpeechStream, } from './stt.js';
+export { StreamAdapter, StreamAdapterWrapper } from './stream_adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/stt/stream_adapter.d.cts

@@ -0,0 +1,18 @@
+import type { AudioFrame } from '@livekit/rtc-node';
+import type { VAD } from '../vad.js';
+import type { SpeechEvent } from './stt.js';
+import { STT, SpeechStream } from './stt.js';
+export declare class StreamAdapter extends STT {
+    #private;
+    label: string;
+    constructor(stt: STT, vad: VAD);
+    _recognize(frame: AudioFrame): Promise<SpeechEvent>;
+    stream(): StreamAdapterWrapper;
+}
+export declare class StreamAdapterWrapper extends SpeechStream {
+    #private;
+    label: string;
+    constructor(stt: STT, vad: VAD);
+    monitorMetrics(): Promise<void>;
+}
+//# sourceMappingURL=stream_adapter.d.ts.map

package/dist/stt/stt.d.cts

@@ -0,0 +1,124 @@
+import type { AudioFrame } from '@livekit/rtc-node';
+import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+import type { STTMetrics } from '../metrics/base.js';
+import type { AudioBuffer } from '../utils.js';
+import { AsyncIterableQueue } from '../utils.js';
+/** Indicates start/middle/end of speech */
+export declare enum SpeechEventType {
+    /**
+     * Indicate the start of speech.
+     * If the STT doesn't support this event, this will be emitted at the same time
+     * as the first INTERIM_TRANSCRIPT.
+     */
+    START_OF_SPEECH = 0,
+    /**
+     * Interim transcript, useful for real-time transcription.
+     */
+    INTERIM_TRANSCRIPT = 1,
+    /**
+     * Final transcript, emitted when the STT is confident enough that a certain
+     * portion of the speech will not change.
+     */
+    FINAL_TRANSCRIPT = 2,
+    /**
+     * Indicate the end of speech, emitted when the user stops speaking.
+     * The first alternative is a combination of all the previous FINAL_TRANSCRIPT events.
+     */
+    END_OF_SPEECH = 3,
+    /** Usage event, emitted periodically to indicate usage metrics. */
+    RECOGNITION_USAGE = 4,
+    METRICS_COLLECTED = 5
+}
+/** SpeechData contains metadata about this {@link SpeechEvent}. */
+export interface SpeechData {
+    language: string;
+    text: string;
+    startTime: number;
+    endTime: number;
+    confidence: number;
+}
+export interface RecognitionUsage {
+    audioDuration: number;
+}
+/** SpeechEvent is a packet of speech-to-text data. */
+export interface SpeechEvent {
+    type: SpeechEventType;
+    alternatives?: [SpeechData, ...SpeechData[]];
+    requestId?: string;
+    recognitionUsage?: RecognitionUsage;
+}
+/**
+ * Describes the capabilities of the STT provider.
+ *
+ * @remarks
+ * At present, the framework only supports providers that have a streaming endpoint.
+ */
+export interface STTCapabilities {
+    streaming: boolean;
+    interimResults: boolean;
+}
+export type STTCallbacks = {
+    [SpeechEventType.METRICS_COLLECTED]: (metrics: STTMetrics) => void;
+};
+declare const STT_base: new () => TypedEmitter<STTCallbacks>;
+/**
+ * An instance of a speech-to-text adapter.
+ *
+ * @remarks
+ * This class is abstract, and as such cannot be used directly. Instead, use a provider plugin that
+ * exports its own child STT class, which inherits this class's methods.
+ */
+export declare abstract class STT extends STT_base {
+    #private;
+    abstract label: string;
+    constructor(capabilities: STTCapabilities);
+    /** Returns this STT's capabilities */
+    get capabilities(): STTCapabilities;
+    /** Receives an audio buffer and returns transcription in the form of a {@link SpeechEvent} */
+    recognize(frame: AudioBuffer): Promise<SpeechEvent>;
+    protected abstract _recognize(frame: AudioBuffer): Promise<SpeechEvent>;
+    /**
+     * Returns a {@link SpeechStream} that can be used to push audio frames and receive
+     * transcriptions
+     */
+    abstract stream(): SpeechStream;
+}
+/**
+ * An instance of a speech-to-text stream, as an asynchronous iterable iterator.
+ *
+ * @example Looping through frames
+ * ```ts
+ * for await (const event of stream) {
+ *   if (event.type === SpeechEventType.FINAL_TRANSCRIPT) {
+ *     console.log(event.alternatives[0].text)
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * This class is abstract, and as such cannot be used directly. Instead, use a provider plugin that
+ * exports its own child SpeechStream class, which inherits this class's methods.
+ */
+export declare abstract class SpeechStream implements AsyncIterableIterator<SpeechEvent> {
+    #private;
+    protected static readonly FLUSH_SENTINEL: unique symbol;
+    protected input: AsyncIterableQueue<AudioFrame | typeof SpeechStream.FLUSH_SENTINEL>;
+    protected output: AsyncIterableQueue<SpeechEvent>;
+    protected queue: AsyncIterableQueue<SpeechEvent>;
+    abstract label: string;
+    protected closed: boolean;
+    constructor(stt: STT);
+    protected monitorMetrics(): Promise<void>;
+    /** Push an audio frame to the STT */
+    pushFrame(frame: AudioFrame): void;
+    /** Flush the STT, causing it to process all pending text */
+    flush(): void;
+    /** Mark the input as ended and forbid additional pushes */
+    endInput(): void;
+    next(): Promise<IteratorResult<SpeechEvent>>;
+    /** Close both the input and output of the STT stream */
+    close(): void;
+    [Symbol.asyncIterator](): SpeechStream;
+}
+export {};
+//# sourceMappingURL=stt.d.ts.map

package/dist/tokenize/basic/basic.d.cts

@@ -0,0 +1,18 @@
+import * as tokenizer from '../tokenizer.js';
+import { splitWords } from './word.js';
+export declare class SentenceTokenizer extends tokenizer.SentenceTokenizer {
+    #private;
+    constructor(language?: string, minSentenceLength?: number, streamContextLength?: number);
+    tokenize(text: string, language?: string): string[];
+    stream(language?: string): tokenizer.SentenceStream;
+}
+export declare class WordTokenizer extends tokenizer.WordTokenizer {
+    #private;
+    constructor(ignorePunctuation?: boolean);
+    tokenize(text: string, language?: string): string[];
+    stream(language?: string): tokenizer.WordStream;
+}
+export declare const hyphenateWord: (word: string) => string[];
+export { splitWords };
+export declare const tokenizeParagraphs: (text: string) => string[];
+//# sourceMappingURL=basic.d.ts.map

package/dist/tokenize/basic/hyphenator.d.cts

@@ -0,0 +1,17 @@
+declare const END: unique symbol;
+interface Tree {
+    [id: string]: Tree | string;
+    [END]?: number[];
+}
+declare class Hyphenator {
+    #private;
+    tree: Tree;
+    exceptions: {
+        [id: string]: number[];
+    };
+    constructor(patterns: string, exceptions: string);
+    hyphenateWord(word: string): string[];
+}
+export declare const hyphenator: Hyphenator;
+export {};
+//# sourceMappingURL=hyphenator.d.ts.map

package/dist/tokenize/basic/index.d.cts

@@ -0,0 +1,2 @@
+export { SentenceTokenizer, WordTokenizer, tokenizeParagraphs, hyphenateWord, splitWords, } from './basic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tokenize/basic/paragraph.d.cts

@@ -0,0 +1,5 @@
+/**
+ * Split the text into paragraphs.
+ */
+export declare const splitParagraphs: (text: string) => [string, number, number][];
+//# sourceMappingURL=paragraph.d.ts.map

package/dist/tokenize/basic/sentence.d.cts

@@ -0,0 +1,5 @@
+/**
+ * Split the text into sentences.
+ */
+export declare const splitSentences: (text: string, minLength?: number) => [string, number, number][];
+//# sourceMappingURL=sentence.d.ts.map

package/dist/tokenize/basic/word.d.cts

@@ -0,0 +1,5 @@
+/**
+ * Split the text into words.
+ */
+export declare const splitWords: (text: string, ignorePunctuation?: boolean) => [string, number, number][];
+//# sourceMappingURL=word.d.ts.map

package/dist/tokenize/index.d.cts

@@ -0,0 +1,5 @@
+import * as basic from './basic/index.js';
+export { type TokenData, SentenceTokenizer, SentenceStream, WordTokenizer, WordStream, } from './tokenizer.js';
+export { BufferedSentenceStream, BufferedTokenStream, BufferedWordStream } from './token_stream.js';
+export { basic };
+//# sourceMappingURL=index.d.ts.map