@pipedog/core 0.0.0 → 0.1.0

package/dist/utils/text/alnum_utils.d.ts

@@ -0,0 +1,109 @@
+/** Python's `ch.isalnum()` for a single character. */
+export declare function isAlnum(ch: string | undefined): boolean;
+/** Python's `ch.isalpha()` for a single character. */
+export declare function isAlpha(ch: string | undefined): boolean;
+/** Python's `ch.isspace()` for a single character. */
+export declare function isSpace(ch: string | undefined): boolean;
+/** Python's `unicodedata.category(ch).startswith("P")` for a single character. */
+export declare function isPunctuation(ch: string | undefined): boolean;
+/** The character (code point) at code unit offset `pos` of `text`. */
+export declare function charAt(text: string, pos: number): string;
+/**
+ * Remove punctuation only at the very end of `text`.
+ *
+ * @param text Input text to trim.
+ * @returns `text` with any trailing run of Unicode punctuation characters removed.
+ */
+export declare function stripTrailingPunctuation(text: string): string;
+/**
+ * Replace typographic punctuation variants with their ASCII equivalents.
+ *
+ * @param text Input text to fold.
+ * @returns `text` with typographic quotes and dashes replaced by ASCII; same
+ *   length as `text`.
+ */
+export declare function foldTypography(text: string): string;
+/**
+ * Fold away surface variation between two spellings of the same text, 1:1.
+ *
+ * Unlike `alnumOnly`, this never removes or merges characters -- punctuation,
+ * spaces, and markup are passed through unchanged, and each output character
+ * corresponds to exactly the same-index input character. A raw offset
+ * computed against the folded text therefore applies unchanged to the
+ * original, so callers can use it as a drop-in transform before a
+ * position-based literal comparison, without the risk of a fully-normalized
+ * (whitespace/punctuation-stripped) comparison matching across a boundary
+ * that wasn't already a candidate in the untransformed comparison.
+ *
+ * Folds case, accents, and typographic punctuation (`’` -> `'`,
+ * `–` -> `-`) -- the variations a TTS service may introduce between the
+ * text it was sent and the words it reports back. Deliberately narrow: each
+ * folded character is listed in `TYPOGRAPHIC_FOLD`, rather than applying a
+ * blanket Unicode compatibility normalization, which would silently fold
+ * thousands of characters (CJK compatibility ideographs, halfwidth katakana,
+ * math alphanumerics) that no service is known to substitute.
+ *
+ * @param text Input text to fold.
+ * @returns `text` with those variations folded away; same length as `text`.
+ */
+export declare function foldForMatching(text: string): string;
+/**
+ * Strip XML/HTML tags then keep only lowercase alphanumeric characters.
+ *
+ * Accented letters (e.g. ã, é) are reduced to their base letter so TTS output
+ * can be matched against LLM text even when the provider strips diacritics.
+ * Non-Latin scripts (CJK, Hangul) are kept as-is — each original character
+ * contributes exactly one char to the result, keeping normalized length in
+ * sync with raw alnum counts used by `advanceByAlnums`.
+ *
+ * @param text Input text to reduce.
+ * @returns Lowercase alphanumeric-only string with tags stripped.
+ */
+export declare function alnumOnly(text: string): string;
+/**
+ * Return true if `text` holds anything alphanumeric once markup is stripped.
+ *
+ * The predicate form of `alnumOnly`, for the question the callers actually
+ * ask: is there anything left to speak here? A tag's letters do not count --
+ * `"<break/>"` is empty by this measure.
+ */
+export declare function hasAlnum(text: string): boolean;
+/**
+ * Return the position in `text` after advancing past `n` characters.
+ *
+ * XML/HTML tags (`<...>`) are crossed without counting against the budget, so
+ * the span returned includes any tag met on the way. Everything else counts,
+ * punctuation and spaces included.
+ *
+ * This keeps a cursor in step with one walking the same content written
+ * without the tags: both move over the same characters, so neither reaches
+ * past what the other has. Where the budget is a count of letters and digits
+ * instead, use `advanceByAlnums`.
+ *
+ * @param text The source text to scan.
+ * @param startPos Starting position in `text`.
+ * @param n Number of characters (code units) to consume.
+ * @returns New position in `text` after consuming `n` characters.
+ */
+export declare function advanceByChars(text: string, startPos: number, n: number): number;
+/**
+ * Return the position in `text` after advancing past `n` alphanumeric chars.
+ *
+ * Moves through the text one character at a time, counting only alphanumeric
+ * characters. XML/HTML tags (`<...>`) are skipped entirely — their content is
+ * not counted against the budget, so the returned span includes the full tag.
+ * Other non-alphanumeric characters (spaces, punctuation) are also passed over
+ * without decrementing the budget.
+ *
+ * After the `n` alnum chars are consumed, advances further past any
+ * immediately following punctuation (e.g. the `,` in `"questions,"` or the `.`
+ * in `"done."`), stopping before the next space, alnum char, or XML tag.
+ *
+ * @param text The source text to scan.
+ * @param startPos Starting position in `text`.
+ * @param n Number of alphanumeric characters (code units) to consume.
+ * @returns New position in `text` after consuming `n` alnum chars and
+ *   trailing punctuation.
+ */
+export declare function advanceByAlnums(text: string, startPos: number, n: number): number;
+//# sourceMappingURL=alnum_utils.d.ts.map

package/dist/utils/text/alnum_utils.js

@@ -0,0 +1,262 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/alnum_utils.py
+/**
+ * Shared alphanumeric utilities for text normalization and cursor advancement.
+ *
+ * Positions and counts are UTF-16 code units, as JavaScript string indices
+ * are (upstream counts code points). Every count produced here (`alnumOnly`
+ * lengths) and every count consumed (`advanceByAlnums`, `advanceByChars`)
+ * uses the same unit, so they stay in step; they only differ from upstream
+ * for characters outside the Basic Multilingual Plane.
+ */
+import { stripCompleteMarkup } from "./markup_utils.js";
+//
+// Python `str` predicates, for one character (code point).
+//
+const ALNUM_RE = /^[\p{L}\p{N}]$/u;
+const ALPHA_RE = /^\p{L}$/u;
+const PUNCT_RE = /^\p{P}$/u;
+// Python's `str.isspace()` set (differs from JS `\s` on \x1c-\x1f, \x85 and \ufeff).
+// The \x1c-\x1f separators are checked by code in `isSpace`.
+const SPACE_RE = /^[\t\n\v\f\r \x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]$/;
+/** Python's `ch.isalnum()` for a single character. */
+export function isAlnum(ch) {
+    return ch !== undefined && ALNUM_RE.test(ch);
+}
+/** Python's `ch.isalpha()` for a single character. */
+export function isAlpha(ch) {
+    return ch !== undefined && ALPHA_RE.test(ch);
+}
+/** Python's `ch.isspace()` for a single character. */
+export function isSpace(ch) {
+    if (ch === undefined)
+        return false;
+    const code = ch.charCodeAt(0);
+    return (ch.length === 1 && code >= 0x1c && code <= 0x1f) || SPACE_RE.test(ch);
+}
+/** Python's `unicodedata.category(ch).startswith("P")` for a single character. */
+export function isPunctuation(ch) {
+    return ch !== undefined && PUNCT_RE.test(ch);
+}
+/** The character (code point) at code unit offset `pos` of `text`. */
+export function charAt(text, pos) {
+    const cp = text.codePointAt(pos);
+    return cp === undefined ? "" : String.fromCodePoint(cp);
+}
+/**
+ * Remove punctuation only at the very end of `text`.
+ *
+ * @param text Input text to trim.
+ * @returns `text` with any trailing run of Unicode punctuation characters removed.
+ */
+export function stripTrailingPunctuation(text) {
+    return text.replace(/\p{P}+$/u, "");
+}
+/**
+ * Typographic punctuation variants mapped to their ASCII equivalents.
+ *
+ * LLMs emit the typographic forms and TTS services may report the ASCII ones
+ * in word-timestamp events (or the reverse). Every entry is a single
+ * character mapped to a single character, which is what lets
+ * `foldForMatching` keep its 1:1 length contract.
+ */
+const TYPOGRAPHIC_FOLD = {
+    "‘": "'", // ‘ LEFT SINGLE QUOTATION MARK
+    "’": "'", // ’ RIGHT SINGLE QUOTATION MARK
+    ʼ: "'", // ʼ MODIFIER LETTER APOSTROPHE
+    "“": '"', // “ LEFT DOUBLE QUOTATION MARK
+    "”": '"', // ” RIGHT DOUBLE QUOTATION MARK
+    "–": "-", // – EN DASH
+    "—": "-", // — EM DASH
+};
+const TYPOGRAPHIC_FOLD_RE = /[\u2018\u2019\u02bc\u201c\u201d\u2013\u2014]/g;
+/**
+ * Replace typographic punctuation variants with their ASCII equivalents.
+ *
+ * @param text Input text to fold.
+ * @returns `text` with typographic quotes and dashes replaced by ASCII; same
+ *   length as `text`.
+ */
+export function foldTypography(text) {
+    return text.replace(TYPOGRAPHIC_FOLD_RE, (ch) => TYPOGRAPHIC_FOLD[ch] ?? ch);
+}
+/**
+ * Lowercase `char`, reduced to its base letter if it carries a combining accent.
+ *
+ * NFD decomposes an accented character into a base letter plus a combining
+ * mark (e.g. `é` -> `e` + `◌́`, category `Mn`); dropping the mark keeps only
+ * the base letter. Always returns exactly one character of the same length,
+ * so callers can rely on a 1:1 length mapping with the input.
+ */
+function foldAccentedChar(char) {
+    const nfd = [...char.normalize("NFD")];
+    let folded;
+    if (nfd.length >= 2 && /^\p{Mn}$/u.test(nfd[1])) {
+        folded = nfd[0].toLowerCase();
+    }
+    else {
+        folded = char.toLowerCase();
+    }
+    // A few lowercase mappings change length (they do in Python too); keep the
+    // 1:1 length contract by leaving such a character as it is.
+    return folded.length === char.length ? folded : char;
+}
+/**
+ * Fold away surface variation between two spellings of the same text, 1:1.
+ *
+ * Unlike `alnumOnly`, this never removes or merges characters -- punctuation,
+ * spaces, and markup are passed through unchanged, and each output character
+ * corresponds to exactly the same-index input character. A raw offset
+ * computed against the folded text therefore applies unchanged to the
+ * original, so callers can use it as a drop-in transform before a
+ * position-based literal comparison, without the risk of a fully-normalized
+ * (whitespace/punctuation-stripped) comparison matching across a boundary
+ * that wasn't already a candidate in the untransformed comparison.
+ *
+ * Folds case, accents, and typographic punctuation (`’` -> `'`,
+ * `–` -> `-`) -- the variations a TTS service may introduce between the
+ * text it was sent and the words it reports back. Deliberately narrow: each
+ * folded character is listed in `TYPOGRAPHIC_FOLD`, rather than applying a
+ * blanket Unicode compatibility normalization, which would silently fold
+ * thousands of characters (CJK compatibility ideographs, halfwidth katakana,
+ * math alphanumerics) that no service is known to substitute.
+ *
+ * @param text Input text to fold.
+ * @returns `text` with those variations folded away; same length as `text`.
+ */
+export function foldForMatching(text) {
+    let folded = "";
+    for (const ch of text) {
+        folded += isAlpha(ch) ? foldAccentedChar(ch) : ch;
+    }
+    return foldTypography(folded);
+}
+/**
+ * Strip XML/HTML tags then keep only lowercase alphanumeric characters.
+ *
+ * Accented letters (e.g. ã, é) are reduced to their base letter so TTS output
+ * can be matched against LLM text even when the provider strips diacritics.
+ * Non-Latin scripts (CJK, Hangul) are kept as-is — each original character
+ * contributes exactly one char to the result, keeping normalized length in
+ * sync with raw alnum counts used by `advanceByAlnums`.
+ *
+ * @param text Input text to reduce.
+ * @returns Lowercase alphanumeric-only string with tags stripped.
+ */
+export function alnumOnly(text) {
+    text = stripCompleteMarkup(text);
+    let result = "";
+    for (const char of text) {
+        // Ignore punctuation, spaces, emojis, etc.
+        // Keep only letters and numbers.
+        if (!isAlnum(char)) {
+            continue;
+        }
+        if (isAlpha(char)) {
+            // Letters, including CJK and Hangul: fold accents, a no-op for scripts
+            // that have none.
+            result += foldAccentedChar(char);
+        }
+        else {
+            // Digits and other alnum-but-not-alphabetic characters: no case or
+            // accent to fold, so keep as-is (lowercase conversion is a no-op).
+            const lower = char.toLowerCase();
+            result += lower.length === char.length ? lower : char;
+        }
+    }
+    return result;
+}
+/**
+ * Return true if `text` holds anything alphanumeric once markup is stripped.
+ *
+ * The predicate form of `alnumOnly`, for the question the callers actually
+ * ask: is there anything left to speak here? A tag's letters do not count --
+ * `"<break/>"` is empty by this measure.
+ */
+export function hasAlnum(text) {
+    return alnumOnly(text).length > 0;
+}
+/**
+ * Return the position in `text` after advancing past `n` characters.
+ *
+ * XML/HTML tags (`<...>`) are crossed without counting against the budget, so
+ * the span returned includes any tag met on the way. Everything else counts,
+ * punctuation and spaces included.
+ *
+ * This keeps a cursor in step with one walking the same content written
+ * without the tags: both move over the same characters, so neither reaches
+ * past what the other has. Where the budget is a count of letters and digits
+ * instead, use `advanceByAlnums`.
+ *
+ * @param text The source text to scan.
+ * @param startPos Starting position in `text`.
+ * @param n Number of characters (code units) to consume.
+ * @returns New position in `text` after consuming `n` characters.
+ */
+export function advanceByChars(text, startPos, n) {
+    let pos = startPos;
+    let count = 0;
+    while (pos < text.length && count < n) {
+        if (text[pos] === "<") {
+            const end = text.indexOf(">", pos);
+            pos = end !== -1 ? end + 1 : pos + 1;
+        }
+        else {
+            const len = charAt(text, pos).length;
+            count += len;
+            pos += len;
+        }
+    }
+    return pos;
+}
+/**
+ * Return the position in `text` after advancing past `n` alphanumeric chars.
+ *
+ * Moves through the text one character at a time, counting only alphanumeric
+ * characters. XML/HTML tags (`<...>`) are skipped entirely — their content is
+ * not counted against the budget, so the returned span includes the full tag.
+ * Other non-alphanumeric characters (spaces, punctuation) are also passed over
+ * without decrementing the budget.
+ *
+ * After the `n` alnum chars are consumed, advances further past any
+ * immediately following punctuation (e.g. the `,` in `"questions,"` or the `.`
+ * in `"done."`), stopping before the next space, alnum char, or XML tag.
+ *
+ * @param text The source text to scan.
+ * @param startPos Starting position in `text`.
+ * @param n Number of alphanumeric characters (code units) to consume.
+ * @returns New position in `text` after consuming `n` alnum chars and
+ *   trailing punctuation.
+ */
+export function advanceByAlnums(text, startPos, n) {
+    let pos = startPos;
+    let count = 0;
+    while (pos < text.length && count < n) {
+        if (text[pos] === "<") {
+            const end = text.indexOf(">", pos);
+            pos = end !== -1 ? end + 1 : pos + 1;
+        }
+        else {
+            const ch = charAt(text, pos);
+            if (isAlnum(ch)) {
+                count += ch.length;
+            }
+            pos += ch.length;
+        }
+    }
+    while (pos < text.length) {
+        if (text[pos] === "<") {
+            break;
+        }
+        const ch = charAt(text, pos);
+        if (isAlnum(ch) || isSpace(ch)) {
+            break;
+        }
+        pos += ch.length;
+    }
+    return pos;
+}
+//# sourceMappingURL=alnum_utils.js.map

package/dist/utils/text/base_text_aggregator.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Built-in text types.
+ *
+ * `BACKCHANNEL` is a short acknowledgment the bot says while the user talks,
+ * such as "Mm-hmm.". Text can also have a type of its own, such as `"code"`.
+ */
+export declare const TextType: {
+    readonly BACKCHANNEL: "backchannel";
+    readonly SENTENCE: "sentence";
+    readonly TOKEN: "token";
+    readonly WORD: "word";
+};
+export type TextType = (typeof TextType)[keyof typeof TextType];
+export interface AggregationOptions {
+    /** The aggregated text content. */
+    text: string;
+    /**
+     * What the text represents: a `TextType` such as a sentence or a word, or a
+     * custom type such as `"code"`.
+     */
+    type: string;
+}
+/**
+ * Data class representing aggregated text and its type.
+ *
+ * An Aggregation object is created whenever a stream of text is aggregated by
+ * a text aggregator. It contains the aggregated text and a type saying what
+ * the text represents.
+ *
+ * - `text`: The aggregated text content.
+ * - `type`: What the text represents: a `TextType` such as a sentence or
+ *   a word, or a custom type such as `"code"`.
+ */
+export declare class Aggregation {
+    text: string;
+    type: string;
+    constructor(options: AggregationOptions);
+    /**
+     * Return a string representation of the aggregation.
+     *
+     * @returns A descriptive string showing the type and text of the aggregation.
+     */
+    toString(): string;
+}
+export interface BaseTextAggregatorOptions {
+    /**
+     * The aggregation strategy to use. SENTENCE buffers text until sentence
+     * boundaries are detected, TOKEN passes text through immediately, and WORD
+     * buffers until word boundaries.
+     */
+    aggregationType?: TextType;
+    /** Language code for sentence detection. */
+    language?: string | null;
+}
+/**
+ * Base class for text aggregators in the Pipecat framework.
+ *
+ * Text aggregators are usually used by the TTS service to aggregate LLM tokens
+ * and decide when the aggregated text should be pushed to the TTS service.
+ *
+ * Text aggregators can also be used to manipulate text while it's being
+ * aggregated (e.g. reasoning blocks can be removed).
+ *
+ * Subclasses must implement all abstract methods to define specific aggregation
+ * logic, text manipulation behavior, and state management for interruptions.
+ */
+export declare abstract class BaseTextAggregator {
+    protected _aggregationType: TextType;
+    protected _language: string;
+    /**
+     * Initialize the base text aggregator.
+     *
+     * @throws Error If `aggregationType` is not a `TextType` (upstream: ValueError).
+     */
+    constructor(options?: BaseTextAggregatorOptions);
+    /** The normalized language code used for sentence detection. */
+    get language(): string;
+    /**
+     * Select a sentence tokenizer without discarding buffered text.
+     *
+     * @param language Language code. Call between generations to keep one
+     *   language for all text within a generation.
+     */
+    setLanguage(language: string | null): void;
+    /** The aggregation type for this aggregator. */
+    get aggregationType(): TextType;
+    /**
+     * The currently aggregated text.
+     *
+     * Subclasses must implement this property to return the text that has
+     * been accumulated so far in their internal buffer or storage.
+     */
+    abstract get text(): Aggregation;
+    /**
+     * Aggregate the specified text and yield completed aggregations.
+     *
+     * This method processes the input text character-by-character internally
+     * and yields Aggregation objects as they complete.
+     *
+     * Subclasses should implement their specific logic for:
+     *
+     * - How to process text character-by-character
+     * - When to consider the aggregated text ready for processing
+     * - What criteria determine text completion (e.g., sentence boundaries)
+     * - When a completion occurs, yield an Aggregation object containing the
+     *   aggregated text (stripped of leading/trailing whitespace) and its type
+     *
+     * @param text The text to be aggregated.
+     * @returns An async iterable of Aggregation objects as they complete. Each
+     *   Aggregation consists of the aggregated text (stripped of
+     *   leading/trailing whitespace) and a type saying what it represents: a
+     *   `TextType` such as a sentence or a word, or a custom type such as
+     *   `"code"`.
+     */
+    abstract aggregate(text: string): AsyncIterable<Aggregation>;
+    /**
+     * Flush any pending aggregation.
+     *
+     * This method is called at the end of a stream (e.g., when receiving
+     * LLMFullResponseEndFrame) to return any text that was buffered.
+     *
+     * @returns An Aggregation object if there is pending text, or null if there
+     *   is no pending text.
+     */
+    abstract flush(): Promise<Aggregation | null>;
+    /**
+     * Handle interruptions in the text aggregation process.
+     *
+     * When an interruption occurs it is possible that we might want to discard
+     * the aggregated text or do some internal modifications to the aggregated text.
+     *
+     * Subclasses should implement this method to define how they respond to
+     * interruptions, such as clearing buffers, resetting state, or preserving
+     * partial content.
+     */
+    abstract handleInterruption(): Promise<void>;
+    /**
+     * Clear the internally aggregated text and reset to initial state.
+     *
+     * Subclasses should implement this method to return the aggregator to its
+     * initial state, discarding any previously accumulated text content and
+     * resetting any internal tracking variables.
+     */
+    abstract reset(): Promise<void>;
+}
+//# sourceMappingURL=base_text_aggregator.d.ts.map

package/dist/utils/text/base_text_aggregator.js

@@ -0,0 +1,102 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/base_text_aggregator.py
+/**
+ * Base text aggregator interface for Pipecat text processing.
+ *
+ * This module defines the abstract base class for text aggregators that
+ * accumulate and process text tokens, typically used by TTS services to
+ * determine when aggregated text should be sent for speech synthesis.
+ *
+ * The deprecated `AggregationType` alias of `TextType` is not ported.
+ */
+import { resolveSentenceTokenizerLanguage } from "../string.js";
+/**
+ * Built-in text types.
+ *
+ * `BACKCHANNEL` is a short acknowledgment the bot says while the user talks,
+ * such as "Mm-hmm.". Text can also have a type of its own, such as `"code"`.
+ */
+export const TextType = {
+    BACKCHANNEL: "backchannel",
+    SENTENCE: "sentence",
+    TOKEN: "token",
+    WORD: "word",
+};
+const TEXT_TYPE_VALUES = new Set(Object.values(TextType));
+/**
+ * Data class representing aggregated text and its type.
+ *
+ * An Aggregation object is created whenever a stream of text is aggregated by
+ * a text aggregator. It contains the aggregated text and a type saying what
+ * the text represents.
+ *
+ * - `text`: The aggregated text content.
+ * - `type`: What the text represents: a `TextType` such as a sentence or
+ *   a word, or a custom type such as `"code"`.
+ */
+export class Aggregation {
+    text;
+    type;
+    constructor(options) {
+        this.text = options.text;
+        this.type = options.type;
+    }
+    /**
+     * Return a string representation of the aggregation.
+     *
+     * @returns A descriptive string showing the type and text of the aggregation.
+     */
+    toString() {
+        return `Aggregation by ${this.type}: ${this.text}`;
+    }
+}
+/**
+ * Base class for text aggregators in the Pipecat framework.
+ *
+ * Text aggregators are usually used by the TTS service to aggregate LLM tokens
+ * and decide when the aggregated text should be pushed to the TTS service.
+ *
+ * Text aggregators can also be used to manipulate text while it's being
+ * aggregated (e.g. reasoning blocks can be removed).
+ *
+ * Subclasses must implement all abstract methods to define specific aggregation
+ * logic, text manipulation behavior, and state management for interruptions.
+ */
+export class BaseTextAggregator {
+    _aggregationType;
+    _language;
+    /**
+     * Initialize the base text aggregator.
+     *
+     * @throws Error If `aggregationType` is not a `TextType` (upstream: ValueError).
+     */
+    constructor(options = {}) {
+        const aggregationType = options.aggregationType ?? TextType.SENTENCE;
+        if (!TEXT_TYPE_VALUES.has(aggregationType)) {
+            throw new Error(`'${aggregationType}' is not a valid TextType`);
+        }
+        this._aggregationType = aggregationType;
+        this._language = resolveSentenceTokenizerLanguage(options.language ?? null);
+    }
+    /** The normalized language code used for sentence detection. */
+    get language() {
+        return this._language;
+    }
+    /**
+     * Select a sentence tokenizer without discarding buffered text.
+     *
+     * @param language Language code. Call between generations to keep one
+     *   language for all text within a generation.
+     */
+    setLanguage(language) {
+        this._language = resolveSentenceTokenizerLanguage(language);
+    }
+    /** The aggregation type for this aggregator. */
+    get aggregationType() {
+        return this._aggregationType;
+    }
+}
+//# sourceMappingURL=base_text_aggregator.js.map

package/dist/utils/text/base_text_filter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Base text filter interface for Pipecat text processing.
+ *
+ * This module defines the abstract base class for text filters that can
+ * modify text content in the processing pipeline, including support for
+ * settings updates and interruption handling.
+ */
+/**
+ * Abstract base class for text filters in the Pipecat framework.
+ *
+ * Text filters are responsible for modifying text content as it flows through
+ * the processing pipeline. They support dynamic settings updates and can
+ * handle interruptions to reset their internal state.
+ *
+ * Subclasses must implement all abstract methods to define specific filtering
+ * behavior, settings management, and interruption handling logic.
+ */
+export declare abstract class BaseTextFilter {
+    constructor(_options?: object);
+    /**
+     * Update the filter's configuration settings.
+     *
+     * Subclasses should implement this method to handle dynamic configuration
+     * updates during runtime, updating internal state as needed.
+     *
+     * @param settings Dictionary of setting names to values for configuration.
+     */
+    updateSettings(_settings: Readonly<Record<string, unknown>>): Promise<void>;
+    /**
+     * Apply filtering transformations to the input text.
+     *
+     * Subclasses must implement this method to define the specific text
+     * transformations that should be applied to the input.
+     *
+     * @param text The input text to be filtered.
+     * @returns The filtered text after applying transformations.
+     */
+    abstract filter(text: string): Promise<string>;
+    /**
+     * Handle interruption events in the processing pipeline.
+     *
+     * Subclasses should implement this method to reset internal state, clear
+     * buffers, or perform other cleanup when an interruption occurs.
+     */
+    handleInterruption(): Promise<void>;
+    /**
+     * Reset the filter state after an interruption has been handled.
+     *
+     * Subclasses should implement this method to restore the filter to normal
+     * operation after an interruption has been processed and resolved.
+     */
+    resetInterruption(): Promise<void>;
+}
+//# sourceMappingURL=base_text_filter.d.ts.map