@pipedog/core 0.0.0 → 0.1.0

package/dist/transcriptions/language.js

@@ -0,0 +1,543 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/transcriptions/language.py
+/**
+ * Language code enumerations for Pipecat.
+ *
+ * This module provides comprehensive language code constants following ISO 639
+ * and BCP 47 standards, supporting both language-only and language-region
+ * combinations for various speech and text processing services.
+ */
+import { logger } from "../utils/logger.js";
+/**
+ * Language codes for speech and text processing services.
+ *
+ * Provides comprehensive language code constants following ISO 639 and BCP 47
+ * standards. Includes both language-only codes (e.g., 'en') and
+ * language-region combinations (e.g., 'en-US') to support various speech
+ * synthesis, recognition, and translation services.
+ */
+export const Language = {
+    // Afrikaans
+    AF: "af",
+    AF_ZA: "af-ZA",
+    // Amharic
+    AM: "am",
+    AM_ET: "am-ET",
+    // Arabic
+    AR: "ar",
+    AR_AE: "ar-AE",
+    AR_BH: "ar-BH",
+    AR_DZ: "ar-DZ",
+    AR_EG: "ar-EG",
+    AR_IQ: "ar-IQ",
+    AR_JO: "ar-JO",
+    AR_KW: "ar-KW",
+    AR_LB: "ar-LB",
+    AR_LY: "ar-LY",
+    AR_MA: "ar-MA",
+    AR_OM: "ar-OM",
+    AR_QA: "ar-QA",
+    AR_SA: "ar-SA",
+    AR_SY: "ar-SY",
+    AR_TN: "ar-TN",
+    AR_XA: "ar-XA",
+    AR_YE: "ar-YE",
+    AR_001: "ar-001",
+    // Assamese
+    AS: "as",
+    AS_IN: "as-IN",
+    // Asturian
+    AST: "ast",
+    // Azerbaijani
+    AZ: "az",
+    AZ_AZ: "az-AZ",
+    // Bashkir
+    BA: "ba",
+    // Belarusian
+    BE: "be",
+    BE_BY: "be-BY",
+    // Bulgarian
+    BG: "bg",
+    BG_BG: "bg-BG",
+    // Bengali
+    BN: "bn",
+    BN_BD: "bn-BD",
+    BN_IN: "bn-IN",
+    // Tibetan
+    BO: "bo",
+    // Breton
+    BR: "br",
+    // Bodo
+    BRX: "brx",
+    BRX_IN: "brx-IN",
+    // Bosnian
+    BS: "bs",
+    BS_BA: "bs-BA",
+    // Catalan
+    CA: "ca",
+    CA_ES: "ca-ES",
+    // Cebuano
+    CEB: "ceb",
+    CEB_PH: "ceb-PH",
+    // Central Kurdish
+    CKB: "ckb",
+    CKB_IQ: "ckb-IQ",
+    CKB_IR: "ckb-IR",
+    // Mandarin Chinese
+    CMN: "cmn",
+    CMN_CN: "cmn-CN",
+    // Czech
+    CS: "cs",
+    CS_CZ: "cs-CZ",
+    // Welsh
+    CY: "cy",
+    CY_GB: "cy-GB",
+    // Danish
+    DA: "da",
+    DA_DK: "da-DK",
+    // German
+    DE: "de",
+    DE_AT: "de-AT",
+    DE_BE: "de-BE",
+    DE_CH: "de-CH",
+    DE_DE: "de-DE",
+    // Dogri
+    DOI: "doi",
+    DOI_IN: "doi-IN",
+    // Greek
+    EL: "el",
+    EL_GR: "el-GR",
+    // English
+    EN: "en",
+    EN_AB: "en-AB",
+    EN_AU: "en-AU",
+    EN_CA: "en-CA",
+    EN_GB: "en-GB",
+    EN_GH: "en-GH",
+    EN_HK: "en-HK",
+    EN_IE: "en-IE",
+    EN_IN: "en-IN",
+    EN_KE: "en-KE",
+    EN_NG: "en-NG",
+    EN_NZ: "en-NZ",
+    EN_PH: "en-PH",
+    EN_SG: "en-SG",
+    EN_TZ: "en-TZ",
+    EN_US: "en-US",
+    EN_WL: "en-WL",
+    EN_ZA: "en-ZA",
+    // Esperanto
+    EO: "eo",
+    // Spanish
+    ES: "es",
+    ES_AR: "es-AR",
+    ES_BO: "es-BO",
+    ES_CL: "es-CL",
+    ES_CO: "es-CO",
+    ES_CR: "es-CR",
+    ES_CU: "es-CU",
+    ES_DO: "es-DO",
+    ES_EC: "es-EC",
+    ES_ES: "es-ES",
+    ES_GQ: "es-GQ",
+    ES_GT: "es-GT",
+    ES_HN: "es-HN",
+    ES_MX: "es-MX",
+    ES_NI: "es-NI",
+    ES_PA: "es-PA",
+    ES_PE: "es-PE",
+    ES_PR: "es-PR",
+    ES_PY: "es-PY",
+    ES_SV: "es-SV",
+    ES_US: "es-US",
+    ES_UY: "es-UY",
+    ES_VE: "es-VE",
+    ES_419: "es-419",
+    // Estonian
+    ET: "et",
+    ET_EE: "et-EE",
+    // Basque
+    EU: "eu",
+    EU_ES: "eu-ES",
+    // Persian
+    FA: "fa",
+    FA_AF: "fa-AF",
+    FA_IR: "fa-IR",
+    // Fulah
+    FF: "ff",
+    // Finnish
+    FI: "fi",
+    FI_FI: "fi-FI",
+    // Filipino
+    FIL: "fil",
+    FIL_PH: "fil-PH",
+    // Faroese
+    FO: "fo",
+    // French
+    FR: "fr",
+    FR_BE: "fr-BE",
+    FR_CA: "fr-CA",
+    FR_CH: "fr-CH",
+    FR_FR: "fr-FR",
+    // Irish
+    GA: "ga",
+    GA_IE: "ga-IE",
+    // Gaelic
+    GD: "gd",
+    // Galician
+    GL: "gl",
+    GL_ES: "gl-ES",
+    // Gujarati
+    GU: "gu",
+    GU_IN: "gu-IN",
+    // Hausa
+    HA: "ha",
+    // Hawaiian
+    HAW: "haw",
+    // Hebrew
+    HE: "he",
+    HE_IL: "he-IL",
+    // Hindi
+    HI: "hi",
+    HI_IN: "hi-IN",
+    // Croatian
+    HR: "hr",
+    HR_HR: "hr-HR",
+    // Haitian Creole
+    HT: "ht",
+    HT_HT: "ht-HT",
+    // Hungarian
+    HU: "hu",
+    HU_HU: "hu-HU",
+    // Armenian
+    HY: "hy",
+    HY_AM: "hy-AM",
+    // Indonesian
+    ID: "id",
+    ID_ID: "id-ID",
+    // Igbo
+    IG: "ig",
+    // Icelandic
+    IS: "is",
+    IS_IS: "is-IS",
+    // Italian
+    IT: "it",
+    IT_IT: "it-IT",
+    IT_CH: "it-CH",
+    // Inuktitut
+    IU_CANS: "iu-Cans",
+    IU_CANS_CA: "iu-Cans-CA",
+    IU_LATN: "iu-Latn",
+    IU_LATN_CA: "iu-Latn-CA",
+    // Japanese
+    JA: "ja",
+    JA_JP: "ja-JP",
+    // Javanese
+    JV: "jv",
+    JV_ID: "jv-ID",
+    JV_JV: "jv-JV",
+    JW: "jw", // Fal requires for Javanese
+    // Georgian
+    KA: "ka",
+    KA_GE: "ka-GE",
+    // Kabuverdianu
+    KEA: "kea",
+    // Kabyle
+    KAB: "kab",
+    KAB_DZ: "kab-DZ",
+    // Kazakh
+    KK: "kk",
+    KK_KZ: "kk-KZ",
+    // Khmer
+    KM: "km",
+    KM_KH: "km-KH",
+    // Kannada
+    KN: "kn",
+    KN_IN: "kn-IN",
+    // Konkani
+    KOK: "kok",
+    KOK_IN: "kok-IN",
+    // Korean
+    KO: "ko",
+    KO_KR: "ko-KR",
+    // Kashmiri
+    KS: "ks",
+    KS_IN: "ks-IN",
+    // Kurdish
+    KU: "ku",
+    // Kyrgyz
+    KY: "ky",
+    KY_KG: "ky-KG",
+    // Latin
+    LA: "la",
+    LA_VA: "la-VA",
+    // Luxembourgish
+    LB: "lb",
+    LB_LU: "lb-LU",
+    // Lingala
+    LN: "ln",
+    // Lao
+    LO: "lo",
+    LO_LA: "lo-LA",
+    // Lithuanian
+    LT: "lt",
+    LT_LT: "lt-LT",
+    // Ganda
+    LG: "lg",
+    // Luo
+    LUO: "luo",
+    // Latvian
+    LV: "lv",
+    LV_LV: "lv-LV",
+    // Malagasy
+    MG: "mg",
+    MG_MG: "mg-MG",
+    // Maori
+    MI: "mi",
+    // Macedonian
+    MK: "mk",
+    MK_MK: "mk-MK",
+    // Maithili
+    MAI: "mai",
+    MAI_IN: "mai-IN",
+    // Malayalam
+    ML: "ml",
+    ML_IN: "ml-IN",
+    // Mongolian
+    MN: "mn",
+    MN_MN: "mn-MN",
+    // Manipuri
+    MNI: "mni",
+    MNI_IN: "mni-IN",
+    // Marathi
+    MR: "mr",
+    MR_IN: "mr-IN",
+    // Malay
+    MS: "ms",
+    MS_MY: "ms-MY",
+    // Maltese
+    MT: "mt",
+    MT_MT: "mt-MT",
+    // Burmese
+    MY: "my",
+    MY_MM: "my-MM",
+    MY_MR: "mymr",
+    // Norwegian
+    NB: "nb", // Norwegian Bokmål
+    NB_NO: "nb-NO",
+    NO: "no",
+    NN: "nn", // Norwegian Nynorsk
+    NN_NO: "nn-NO",
+    // Nepali
+    NE: "ne",
+    NE_IN: "ne-IN",
+    NE_NP: "ne-NP",
+    // Dutch
+    NL: "nl",
+    NL_BE: "nl-BE",
+    NL_NL: "nl-NL",
+    // Northern Sotho
+    NSO: "nso",
+    // Chichewa
+    NY: "ny",
+    // Occitan
+    OC: "oc",
+    // Odia
+    OR: "or",
+    OR_IN: "or-IN",
+    // Punjabi
+    PA: "pa",
+    PA_IN: "pa-IN",
+    // Polish
+    PL: "pl",
+    PL_PL: "pl-PL",
+    // Pashto
+    PS: "ps",
+    PS_AF: "ps-AF",
+    // Portuguese
+    PT: "pt",
+    PT_BR: "pt-BR",
+    PT_PT: "pt-PT",
+    // Romanian
+    RO: "ro",
+    RO_RO: "ro-RO",
+    // Russian
+    RU: "ru",
+    RU_RU: "ru-RU",
+    // Sanskrit
+    SA: "sa",
+    SA_IN: "sa-IN",
+    // Santali
+    SAT: "sat",
+    SAT_IN: "sat-IN",
+    // Sindhi
+    SD: "sd",
+    SD_IN: "sd-IN",
+    // Sinhala
+    SI: "si",
+    SI_LK: "si-LK",
+    // Slovak
+    SK: "sk",
+    SK_SK: "sk-SK",
+    // Slovenian
+    SL: "sl",
+    SL_SI: "sl-SI",
+    // Shona
+    SN: "sn",
+    // Somali
+    SO: "so",
+    SO_SO: "so-SO",
+    // Albanian
+    SQ: "sq",
+    SQ_AL: "sq-AL",
+    // Serbian
+    SR: "sr",
+    SR_RS: "sr-RS",
+    SR_LATN: "sr-Latn",
+    SR_LATN_RS: "sr-Latn-RS",
+    // Sundanese
+    SU: "su",
+    SU_ID: "su-ID",
+    // Swedish
+    SV: "sv",
+    SV_SE: "sv-SE",
+    // Swahili
+    SW: "sw",
+    SW_BI: "sw-BI",
+    SW_KE: "sw-KE",
+    SW_RW: "sw-RW",
+    SW_TZ: "sw-TZ",
+    SW_UG: "sw-UG",
+    // Tamil
+    TA: "ta",
+    TA_IN: "ta-IN",
+    TA_LK: "ta-LK",
+    TA_MY: "ta-MY",
+    TA_SG: "ta-SG",
+    // Telugu
+    TE: "te",
+    TE_IN: "te-IN",
+    // Tajik
+    TG: "tg",
+    // Thai
+    TH: "th",
+    TH_TH: "th-TH",
+    // Turkmen
+    TK: "tk",
+    // Tagalog
+    TL: "tl",
+    // Turkish
+    TR: "tr",
+    TR_TR: "tr-TR",
+    // Tatar
+    TT: "tt",
+    // Uyghur
+    UG: "ug",
+    // Ukrainian
+    UK: "uk",
+    UK_UA: "uk-UA",
+    // Umbundu
+    UMB: "umb",
+    // Urdu
+    UR: "ur",
+    UR_IN: "ur-IN",
+    UR_PK: "ur-PK",
+    // Uzbek
+    UZ: "uz",
+    UZ_UZ: "uz-UZ",
+    // Vietnamese
+    VI: "vi",
+    VI_VN: "vi-VN",
+    // Wolof
+    WO: "wo",
+    // Wu Chinese
+    WUU: "wuu",
+    WUU_CN: "wuu-CN",
+    // Yiddish
+    YI: "yi",
+    // Yoruba
+    YO: "yo",
+    // Yue Chinese (Cantonese)
+    YUE: "yue",
+    YUE_CN: "yue-CN",
+    // Chinese
+    ZH: "zh",
+    ZH_CN: "zh-CN",
+    ZH_CN_GUANGXI: "zh-CN-guangxi",
+    ZH_CN_HENAN: "zh-CN-henan",
+    ZH_CN_LIAONING: "zh-CN-liaoning",
+    ZH_CN_SHAANXI: "zh-CN-shaanxi",
+    ZH_CN_SHANDONG: "zh-CN-shandong",
+    ZH_CN_SICHUAN: "zh-CN-sichuan",
+    ZH_HK: "zh-HK",
+    ZH_TW: "zh-TW",
+    // Xhosa
+    XH: "xh-ZA",
+    // Zulu
+    ZU: "zu",
+    ZU_ZA: "zu-ZA",
+};
+const LANGUAGE_VALUES = new Set(Object.values(Language));
+/** Whether `value` is one of the Language codes (Python's `Language(value)` not raising). */
+export function isLanguage(value) {
+    return LANGUAGE_VALUES.has(value);
+}
+/**
+ * Resolve a Language value to a service-specific language code.
+ *
+ * Checks the language map first, then falls back to extracting the
+ * appropriate code format with a warning if not found in the verified list.
+ *
+ * @param language The Language value to convert.
+ * @param languageMap Mapping from Language values to service language codes.
+ * @param useBaseCode If true, a regional variant resolves through its base
+ *   language: the map's code for the base language (e.g. 'eng' for 'en-US'
+ *   when the map has `[Language.EN]: "eng"`), or the base code itself (e.g.
+ *   'en') when the map has no entry for it. If false, uses full language code
+ *   as-is.
+ * @returns The resolved language code for the service.
+ *
+ * @example
+ * // Service expecting base codes (e.g., Cartesia)
+ * const LANGUAGE_MAP = { [Language.EN]: "en", [Language.ES]: "es" };
+ * resolveLanguage(Language.EN_US, LANGUAGE_MAP, true);
+ * // Logs: "Language en-US not verified. Using base code 'en'."
+ * // => "en"
+ *
+ * // Service with its own code per base language (e.g., ElevenLabs STT)
+ * const LANGUAGE_MAP = { [Language.EN]: "eng", [Language.ES]: "spa" };
+ * resolveLanguage(Language.EN_US, LANGUAGE_MAP, true);
+ * // Logs: "Language en-US not verified. Using base code 'eng'."
+ * // => "eng"
+ *
+ * // Service expecting full codes (e.g., AWS)
+ * const LANGUAGE_MAP = { [Language.EN_US]: "en-US", [Language.ES_ES]: "es-ES" };
+ * resolveLanguage(Language.EN_GB, LANGUAGE_MAP, false);
+ * // Logs: "Language en-GB not verified. Using 'en-GB'."
+ * // => "en-GB"
+ */
+export function resolveLanguage(language, languageMap, useBaseCode = true) {
+    // Check if language is in the verified map
+    const result = languageMap[language];
+    if (result !== undefined && result !== null) {
+        return result;
+    }
+    // Not in map - fall back with warning
+    const langStr = String(language);
+    if (useBaseCode) {
+        // Extract base code (e.g., "en" from "en-US"), then prefer the map's code
+        // for that base language when the service names it differently.
+        let baseCode = langStr.split("-")[0].toLowerCase();
+        if (isLanguage(baseCode)) {
+            baseCode = languageMap[baseCode] ?? baseCode;
+        }
+        logger.warning(`Language ${language} not verified. Using base code '${baseCode}'.`);
+        return baseCode;
+    }
+    logger.warning(`Language ${language} not verified. Using '${langStr}'.`);
+    return langStr;
+}
+//# sourceMappingURL=language.js.map

package/dist/transports/base_input.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Base input transport implementation for Pipecat.
+ *
+ * This module provides the BaseInputTransport class which handles audio and
+ * video input processing.
+ */
+import { Queue, type Task } from "@pipedog/asyncio";
+import { CancelFrame, EndFrame, type Frame, InputAudioRawFrame, type InputImageRawFrame, StartFrame, StopFrame, type UserImageRequestFrame } from "../frames/frames.ts";
+import { BotCapabilities } from "../pipeline/capabilities.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions, type FrameProcessorSetup } from "../processors/frame_processor.ts";
+import type { TransportParams } from "./base_transport.ts";
+export declare const AUDIO_INPUT_TIMEOUT_SECS = 0.5;
+/**
+ * Base class for input transport implementations.
+ *
+ * Handles audio and video input processing including Voice Activity
+ * Detection, turn analysis, audio filtering, and user interaction management.
+ * Supports interruption handling and provides hooks for transport-specific
+ * implementations.
+ *
+ * The deprecated `start_audio_in_streaming()` is not ported: push an
+ * InputTransportStartAudioStreamingFrame instead, and override
+ * `_startAudioInStreaming()` in subclasses.
+ */
+export declare class BaseInputTransport extends FrameProcessor {
+    protected _params: TransportParams;
+    protected _sampleRate: number;
+    protected _botSpeaking: boolean;
+    protected _userSpeaking: boolean;
+    protected _userSpeakingFrameTime: number;
+    protected _userSpeakingFramePeriod: number;
+    protected _audioTask: Task<unknown> | null;
+    protected _audioInQueue: Queue<InputAudioRawFrame>;
+    protected _paused: boolean;
+    /**
+     * Initialize the base input transport.
+     *
+     * @param params Transport configuration parameters.
+     * @param options Additional options passed to the parent class.
+     */
+    constructor(params: TransportParams, options?: FrameProcessorOptions);
+    /**
+     * Enable or disable audio streaming on transport start.
+     *
+     * @param enabled Whether to start audio streaming immediately on transport start.
+     */
+    enableAudioInStreamOnStart(enabled: boolean): void;
+    /**
+     * Start audio input streaming.
+     *
+     * Override in subclasses to implement transport-specific audio streaming.
+     * Triggered by an `InputTransportStartAudioStreamingFrame`.
+     */
+    protected _startAudioInStreaming(): Promise<void>;
+    /** The current audio sample rate in Hz. */
+    get sampleRate(): number;
+    /**
+     * Complete image requests that no frame will answer, with an error.
+     *
+     * The function call that made each request would otherwise never finish.
+     *
+     * @param requests The image requests to complete.
+     * @param error Why no frame will answer them.
+     */
+    protected _answerImageRequests(requests: UserImageRequestFrame[], error: string): Promise<void>;
+    /**
+     * Whether this transport captures a video source listed in `videoInSources`.
+     *
+     * Transports that support `videoInSources` override this. A listed source
+     * this returns false for is ignored, with a warning.
+     *
+     * @param videoSource The video source, e.g. `"camera"` or `"screenVideo"`.
+     * @returns Whether the source is captured as its user connects.
+     */
+    protected _supportsVideoInSource(_videoSource: string): boolean;
+    /**
+     * The media this transport receives from the user.
+     *
+     * The `audio_in`, `video_in` and `screen_in` capabilities. `screen_in` is
+     * unknown when video input is enabled without `videoInSources`, since the
+     * application then decides which sources to capture, and when the transport
+     * doesn't capture screen shares through `videoInSources`.
+     */
+    get capabilities(): BotCapabilities;
+    /**
+     * Set up the transport.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Release input transport resources at teardown. */
+    cleanup(): Promise<void>;
+    /**
+     * Start the input transport and initialize components.
+     *
+     * @param frame The start frame containing initialization parameters.
+     */
+    start(_frame: StartFrame): Promise<void>;
+    /**
+     * Stop the input transport and cleanup resources.
+     *
+     * @param frame The end frame signaling transport shutdown.
+     */
+    stop(_frame: EndFrame): Promise<void>;
+    /**
+     * Pause the input transport temporarily.
+     *
+     * @param frame The stop frame signaling transport pause.
+     */
+    pause(_frame: StopFrame): Promise<void>;
+    /**
+     * Cancel the input transport and stop all processing.
+     *
+     * @param frame The cancel frame signaling immediate cancellation.
+     */
+    cancel(_frame: CancelFrame): Promise<void>;
+    /**
+     * Called when the transport is ready to stream.
+     *
+     * @param frame The start frame containing initialization parameters.
+     */
+    setTransportReady(_frame: StartFrame): Promise<void>;
+    /**
+     * Push a video frame downstream if video input is enabled.
+     *
+     * @param frame The input video frame to process.
+     */
+    pushVideoFrame(frame: InputImageRawFrame): Promise<void>;
+    /**
+     * Push an audio frame to the processing queue if audio input is enabled.
+     *
+     * @param frame The input audio frame to process.
+     */
+    pushAudioFrame(frame: InputAudioRawFrame): Promise<void>;
+    /**
+     * Process incoming frames and handle transport-specific logic.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Create the audio processing task if audio input is enabled. */
+    protected _createAudioTask(): void;
+    /** Cancel and cleanup the audio processing task. */
+    protected _cancelAudioTask(): Promise<void>;
+    /** Main audio processing task handler. */
+    protected _audioTaskHandler(): Promise<void>;
+}
+//# sourceMappingURL=base_input.d.ts.map