@pipedog/core 0.0.0 → 0.1.0

package/dist/processors/metrics/frame_processor_metrics.js

@@ -0,0 +1,372 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/metrics/frame_processor_metrics.py
+/** Frame processor metrics collection and reporting. */
+import { time } from "@pipedog/asyncio";
+import { detectSpeechOnset } from "../../audio/utils.js";
+import { MetricsFrame } from "../../frames/frames.js";
+import { LLMUsageMetricsData, MetricsData, ProcessingMetricsData, STTUsageMetricsData, TextAggregationMetricsData, TTFAMetricsData, TTFATMetricsData, TTFBMetricsData, TTSUsageMetricsData, } from "../../metrics/metrics.js";
+import { BaseObject } from "../../utils/base_object.js";
+import { logger } from "../../utils/logger.js";
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+/**
+ * Metrics collection and reporting for frame processors.
+ *
+ * Provides comprehensive metrics tracking for frame processing operations,
+ * including timing measurements, resource usage, and performance analytics.
+ * Supports TTFB tracking, TTFA tracking, processing duration metrics, and
+ * usage statistics for LLM, STT, and TTS operations.
+ */
+export class FrameProcessorMetrics extends BaseObject {
+    // Cap on buffered audio while waiting for a TTFA speech onset, so a response
+    // that is all silence (or never becomes audible) can't grow the buffer without
+    // bound.
+    static _TTFA_MAX_BUFFER_SECONDS = 3.0;
+    _startTtfbTime = 0;
+    _startProcessingTime = 0;
+    _startTextAggregationTime = 0;
+    _lastTtfbTime = 0;
+    _shouldReportTtfb = true;
+    // TTFA (time-to-first-audio) state. TTFA extends TTFB: scanning for the
+    // first audible sample begins when TTFB stops (see stopTtfbMetrics).
+    // Audio is buffered across chunks until a sustained onset is confirmed.
+    _ttfaActive = false;
+    _ttfaBuffer = new Uint8Array(0);
+    // TTFAT (time-to-first-answer-token) state. TTFAT extends TTFB the same
+    // way, so it keeps the request start that stopTtfbMetrics clears.
+    _ttfatActive = false;
+    _startTtfatTime = 0;
+    // Set by setProcessorName() / setCoreMetricsData(); FrameProcessor sets it
+    // right after construction.
+    _coreMetricsData;
+    /**
+     * The current TTFB value in seconds, or null if not measured.
+     */
+    get ttfb() {
+        if (this._lastTtfbTime > 0) {
+            return this._lastTtfbTime;
+        }
+        // If TTFB is in progress, calculate current value
+        if (this._startTtfbTime > 0) {
+            return time() - this._startTtfbTime;
+        }
+        return null;
+    }
+    /** Get the processor name from core metrics data. */
+    _processorName() {
+        return this._coreMetricsData.processor;
+    }
+    /** Get the model name from core metrics data. */
+    _modelName() {
+        return this._coreMetricsData.model;
+    }
+    /**
+     * Set the core metrics data for this collector.
+     *
+     * @param data The core metrics data containing processor and model information.
+     */
+    setCoreMetricsData(data) {
+        this._coreMetricsData = data;
+    }
+    /**
+     * Set the processor name for metrics reporting.
+     *
+     * @param name The name of the processor to use in metrics.
+     */
+    setProcessorName(name) {
+        this._coreMetricsData = new MetricsData({ processor: name });
+    }
+    /**
+     * Start measuring time-to-first-byte (TTFB).
+     *
+     * @param options.startTime Optional timestamp to use as the start time. If
+     *   null, uses the current time.
+     * @param options.reportOnlyInitialTtfb Whether to report only the first TTFB measurement.
+     */
+    async startTtfbMetrics(options) {
+        // A response that was interrupted before its first answer token leaves
+        // TTFAT armed; drop it so this request measures its own. This is TTFAT
+        // state rather than TTFB reporting policy, so it happens regardless of
+        // whether this request's TTFB will be reported.
+        this._ttfatActive = false;
+        this._startTtfatTime = 0;
+        if (this._shouldReportTtfb) {
+            // `||` on purpose: upstream uses `start_time or time.time()`.
+            this._startTtfbTime = options.startTime || time();
+            this._lastTtfbTime = 0;
+            this._shouldReportTtfb = !options.reportOnlyInitialTtfb;
+        }
+    }
+    /**
+     * Abandon the current TTFB measurement without reporting it.
+     *
+     * For a request whose response never came: there is no interval to
+     * report, and leaving the measurement open would let the next unrelated
+     * output be measured against it.
+     */
+    async cancelTtfbMetrics() {
+        this._startTtfbTime = 0;
+    }
+    /**
+     * Stop TTFB measurement and generate metrics frame.
+     *
+     * TTFB ends at the first output the service produces, of any kind —
+     * including content a caller never sees, such as an LLM's reasoning. Events
+     * that merely acknowledge the request (an HTTP response head, a stream-open
+     * or keepalive event) carry no output and must not stop it, or TTFB
+     * measures connection setup rather than the service's response.
+     *
+     * Only the first call per measurement takes effect, so services can call
+     * this from every branch that handles output rather than tracking which
+     * arrived first.
+     *
+     * @param options.endTime Optional timestamp to use as the end time. If null,
+     *   uses the current time.
+     * @returns MetricsFrame containing TTFB data, or null if not measuring.
+     */
+    async stopTtfbMetrics(options = {}) {
+        if (this._startTtfbTime === 0) {
+            return null;
+        }
+        const endTime = options.endTime || time();
+        if (endTime < this._startTtfbTime) {
+            // The output being measured predates the request it is measured
+            // from, so it cannot be a response to it -- a caller measuring to a
+            // stale timestamp, or a wall clock that stepped backwards mid
+            // measurement. Either way there is no interval to report.
+            logger.warning(`${this._processorName()} TTFB not reported: output predates the ` +
+                `start of the measurement by ${(this._startTtfbTime - endTime).toFixed(3)}s`);
+            this._startTtfbTime = 0;
+            return null;
+        }
+        this._lastTtfbTime = endTime - this._startTtfbTime;
+        logger.debug(`${this._processorName()} TTFB: ${this._lastTtfbTime.toFixed(3)}s`);
+        const ttfb = new TTFBMetricsData({
+            processor: this._processorName(),
+            value: this._lastTtfbTime,
+            model: this._modelName(),
+        });
+        // The first byte has arrived; begin scanning leading silence so TTFA can
+        // be reported as TTFB plus the silence duration (see processTtfaMetrics).
+        this._ttfaActive = true;
+        this._ttfaBuffer = new Uint8Array(0);
+        // Likewise for TTFAT, which needs the request start that is cleared below
+        // (see stopTtfatMetrics).
+        this._ttfatActive = true;
+        this._startTtfatTime = this._startTtfbTime;
+        this._startTtfbTime = 0;
+        return new MetricsFrame({ data: [ttfb] });
+    }
+    /**
+     * Scan buffered audio for speech onset and report TTFA.
+     *
+     * TTFA extends TTFB: once `stopTtfbMetrics` records the first byte, audio
+     * is buffered across chunks (the leading silence may span several, and
+     * onset confirmation needs a little audio past it) and scanned for a
+     * sustained speech onset. When found, TTFB plus the leading-silence
+     * duration is emitted and measuring stops until the next response.
+     *
+     * @param options.audio Raw PCM audio bytes (16-bit signed integers).
+     * @param options.sampleRate Sample rate of the audio in Hz.
+     * @param options.numChannels Number of interleaved audio channels.
+     * @returns MetricsFrame containing TTFA data once onset is confirmed,
+     *   otherwise null.
+     */
+    async processTtfaMetrics(options) {
+        const { audio, sampleRate, numChannels } = options;
+        if (!this._ttfaActive || sampleRate <= 0) {
+            return null;
+        }
+        this._ttfaBuffer = concatBytes(this._ttfaBuffer, audio);
+        const onset = detectSpeechOnset(this._ttfaBuffer, sampleRate, numChannels);
+        if (onset === null || onset === undefined) {
+            // No confirmed onset yet. Bound memory against pathologically long
+            // (or never-arriving) silence by giving up past a sane limit.
+            const maxSeconds = FrameProcessorMetrics._TTFA_MAX_BUFFER_SECONDS;
+            const maxBytes = Math.trunc(maxSeconds * sampleRate * Math.max(numChannels, 1) * 2);
+            if (this._ttfaBuffer.length >= maxBytes) {
+                logger.debug(`${this._processorName()} TTFA: no onset within ` +
+                    `${maxSeconds.toFixed(0)}s of audio; not reporting`);
+                this._ttfaActive = false;
+                this._ttfaBuffer = new Uint8Array(0);
+            }
+            return null;
+        }
+        const silenceDuration = onset / sampleRate;
+        const value = this._lastTtfbTime + silenceDuration;
+        logger.debug(`${this._processorName()} TTFA: ${value.toFixed(3)}s (${silenceDuration.toFixed(3)}s leading silence)`);
+        const ttfa = new TTFAMetricsData({
+            processor: this._processorName(),
+            ttfa: value,
+            leadingSilence: silenceDuration,
+            ttfb: this._lastTtfbTime,
+            model: this._modelName(),
+        });
+        this._ttfaActive = false;
+        this._ttfaBuffer = new Uint8Array(0);
+        return new MetricsFrame({ data: [ttfa] });
+    }
+    /**
+     * Stop TTFAT measurement and generate metrics frame.
+     *
+     * TTFAT extends TTFB: it runs from the same request start but ends at the
+     * first token of the answer the caller sees, so anything the model streams
+     * first — reasoning, most often — falls between the two. Measuring it at
+     * the point a service produces the token, rather than where the pipeline
+     * releases it, keeps buffering downstream of the service out of the number.
+     *
+     * Only the first call per measurement takes effect, so services can call
+     * this from every branch that produces an answer — streamed text, and the
+     * start of a tool call on a turn that answers with one instead of text.
+     *
+     * @param options.endTime Optional timestamp to use as the end time. If null,
+     *   uses the current time.
+     * @returns MetricsFrame containing TTFAT data, or null if not measuring.
+     */
+    async stopTtfatMetrics(options = {}) {
+        if (!this._ttfatActive || this._startTtfatTime === 0) {
+            return null;
+        }
+        const endTime = options.endTime || time();
+        const value = endTime - this._startTtfatTime;
+        const thinkingTime = value - this._lastTtfbTime;
+        logger.debug(`${this._processorName()} TTFAT: ${value.toFixed(3)}s (${thinkingTime.toFixed(3)}s thinking)`);
+        const ttfat = new TTFATMetricsData({
+            processor: this._processorName(),
+            ttfat: value,
+            ttfb: this._lastTtfbTime,
+            thinkingTime,
+            model: this._modelName(),
+        });
+        this._ttfatActive = false;
+        this._startTtfatTime = 0;
+        return new MetricsFrame({ data: [ttfat] });
+    }
+    /**
+     * Start measuring processing time.
+     *
+     * @param options.startTime Optional timestamp to use as the start time. If
+     *   null, uses the current time.
+     */
+    async startProcessingMetrics(options = {}) {
+        this._startProcessingTime = options.startTime || time();
+    }
+    /**
+     * Stop processing time measurement and generate metrics frame.
+     *
+     * @param options.endTime Optional timestamp to use as the end time. If null,
+     *   uses the current time.
+     * @returns MetricsFrame containing processing duration data, or null if not measuring.
+     */
+    async stopProcessingMetrics(options = {}) {
+        if (this._startProcessingTime === 0) {
+            return null;
+        }
+        const endTime = options.endTime || time();
+        const value = endTime - this._startProcessingTime;
+        logger.debug(`${this._processorName()} processing time: ${value.toFixed(3)}s`);
+        const processing = new ProcessingMetricsData({
+            processor: this._processorName(),
+            value,
+            model: this._modelName(),
+        });
+        this._startProcessingTime = 0;
+        return new MetricsFrame({ data: [processing] });
+    }
+    /**
+     * Record LLM token usage metrics.
+     *
+     * @param tokens Token usage information including prompt and completion tokens.
+     * @returns MetricsFrame containing LLM usage data.
+     */
+    async startLlmUsageMetrics(tokens) {
+        let logstr = `${this._processorName()} prompt tokens: ${tokens.promptTokens}, completion tokens: ${tokens.completionTokens}`;
+        if (tokens.cacheReadInputTokens) {
+            logstr += `, cache read input tokens: ${tokens.cacheReadInputTokens}`;
+        }
+        if (tokens.cacheCreationInputTokens) {
+            logstr += `, cache creation input tokens: ${tokens.cacheCreationInputTokens}`;
+        }
+        if (tokens.reasoningTokens) {
+            logstr += `, reasoning tokens: ${tokens.reasoningTokens}`;
+        }
+        if (tokens.inputAudioTokens) {
+            logstr += `, input audio tokens: ${tokens.inputAudioTokens}`;
+        }
+        if (tokens.outputAudioTokens) {
+            logstr += `, output audio tokens: ${tokens.outputAudioTokens}`;
+        }
+        if (tokens.cacheReadInputAudioTokens) {
+            logstr += `, cache read input audio tokens: ${tokens.cacheReadInputAudioTokens}`;
+        }
+        logger.debug(logstr);
+        const value = new LLMUsageMetricsData({
+            processor: this._processorName(),
+            model: this._modelName(),
+            value: tokens,
+        });
+        return new MetricsFrame({ data: [value] });
+    }
+    /**
+     * Record STT usage metrics.
+     *
+     * @param usage Usage information for the STT operation.
+     * @returns MetricsFrame containing STT usage data.
+     */
+    async startSttUsageMetrics(usage) {
+        logger.debug(`${this._processorName()} usage audio seconds: ${usage.audioSeconds.toFixed(3)}`);
+        const value = new STTUsageMetricsData({
+            processor: this._processorName(),
+            model: this._modelName(),
+            value: usage,
+        });
+        return new MetricsFrame({ data: [value] });
+    }
+    /**
+     * Record TTS character usage metrics.
+     *
+     * @param text The text being processed by TTS.
+     * @returns MetricsFrame containing TTS usage data.
+     */
+    async startTtsUsageMetrics(text) {
+        const characters = new TTSUsageMetricsData({
+            processor: this._processorName(),
+            model: this._modelName(),
+            // Python's len() counts code points, not UTF-16 units.
+            value: [...text].length,
+        });
+        logger.debug(`${this._processorName()} usage characters: ${characters.value}`);
+        return new MetricsFrame({ data: [characters] });
+    }
+    /** Start measuring text aggregation time (first token to first sentence). */
+    async startTextAggregationMetrics() {
+        this._startTextAggregationTime = time();
+    }
+    /**
+     * Stop text aggregation measurement and generate metrics frame.
+     *
+     * @returns MetricsFrame containing text aggregation time, or null if not measuring.
+     */
+    async stopTextAggregationMetrics() {
+        if (this._startTextAggregationTime === 0) {
+            return null;
+        }
+        const value = time() - this._startTextAggregationTime;
+        logger.debug(`${this._processorName()} text aggregation time: ${value}`);
+        const aggregation = new TextAggregationMetricsData({
+            processor: this._processorName(),
+            value,
+            model: this._modelName(),
+        });
+        this._startTextAggregationTime = 0;
+        return new MetricsFrame({ data: [aggregation] });
+    }
+}
+//# sourceMappingURL=frame_processor_metrics.js.map

package/dist/processors/metrics/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/processors/metrics/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/metrics/__init__.py
+// The upstream package initializer is empty; import the modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/processors/producer_processor.d.ts

@@ -0,0 +1,68 @@
+/** Producer processor for frame filtering and distribution. */
+import { Queue } from "@pipedog/asyncio";
+import type { Frame } from "../frames/frames.ts";
+import { type FrameDirection, FrameProcessor } from "./frame_processor.ts";
+/** Async function transforming a frame before it is handed on. */
+export type FrameTransformer = (frame: Frame) => Promise<Frame>;
+/** Async function deciding whether a frame should be produced. */
+export type FrameFilter = (frame: Frame) => Promise<boolean>;
+/**
+ * Default transformer that returns the frame unchanged.
+ *
+ * @param frame The frame to transform.
+ * @returns The same frame without modifications.
+ */
+export declare function identityTransformer(frame: Frame): Promise<Frame>;
+export interface ProducerProcessorOptions {
+    /**
+     * Async function that determines if a frame should be produced. Must return
+     * true for frames to be sent to consumers.
+     */
+    filter: FrameFilter;
+    /**
+     * Async function to transform frames before sending to consumers. Defaults
+     * to `identityTransformer` which returns frames unchanged.
+     */
+    transformer?: FrameTransformer;
+    /**
+     * Whether to pass frames through to the next processor. If true, all frames
+     * continue downstream regardless of filter result.
+     */
+    passthrough?: boolean;
+}
+/**
+ * A processor that filters frames and distributes them to multiple consumers.
+ *
+ * This processor receives frames, applies a filter to determine which frames
+ * should be sent to consumers (ConsumerProcessor), optionally transforms those
+ * frames, and distributes them to registered consumer queues. It can also pass
+ * frames through to the next processor in the pipeline.
+ */
+export declare class ProducerProcessor extends FrameProcessor {
+    protected _filter: FrameFilter;
+    protected _transformer: FrameTransformer;
+    protected _passthrough: boolean;
+    protected _consumers: Queue<Frame>[];
+    /** Initialize the producer processor. */
+    constructor(options: ProducerProcessorOptions);
+    /**
+     * Add a new consumer and return its associated queue.
+     *
+     * @returns The queue for the newly added consumer.
+     */
+    addConsumer(): Queue<Frame>;
+    /**
+     * Process an incoming frame and determine whether to produce it.
+     *
+     * If the frame meets the filter criteria, it will be transformed and added
+     * to all consumer queues. If passthrough is enabled, the original frame will
+     * also be sent downstream.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of the frame flow.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Produce a frame to all consumers. */
+    protected _produce(frame: Frame): Promise<void>;
+}
+//# sourceMappingURL=producer_processor.d.ts.map

package/dist/processors/producer_processor.js

@@ -0,0 +1,78 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/producer_processor.py
+/** Producer processor for frame filtering and distribution. */
+import { Queue } from "@pipedog/asyncio";
+import { FrameProcessor } from "./frame_processor.js";
+/**
+ * Default transformer that returns the frame unchanged.
+ *
+ * @param frame The frame to transform.
+ * @returns The same frame without modifications.
+ */
+export async function identityTransformer(frame) {
+    return frame;
+}
+/**
+ * A processor that filters frames and distributes them to multiple consumers.
+ *
+ * This processor receives frames, applies a filter to determine which frames
+ * should be sent to consumers (ConsumerProcessor), optionally transforms those
+ * frames, and distributes them to registered consumer queues. It can also pass
+ * frames through to the next processor in the pipeline.
+ */
+export class ProducerProcessor extends FrameProcessor {
+    _filter;
+    _transformer;
+    _passthrough;
+    _consumers = [];
+    /** Initialize the producer processor. */
+    constructor(options) {
+        super();
+        this._filter = options.filter;
+        this._transformer = options.transformer ?? identityTransformer;
+        this._passthrough = options.passthrough ?? true;
+    }
+    /**
+     * Add a new consumer and return its associated queue.
+     *
+     * @returns The queue for the newly added consumer.
+     */
+    addConsumer() {
+        const queue = new Queue();
+        this._consumers.push(queue);
+        return queue;
+    }
+    /**
+     * Process an incoming frame and determine whether to produce it.
+     *
+     * If the frame meets the filter criteria, it will be transformed and added
+     * to all consumer queues. If passthrough is enabled, the original frame will
+     * also be sent downstream.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of the frame flow.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (await this._filter(frame)) {
+            await this._produce(frame);
+            if (this._passthrough) {
+                await this.pushFrame(frame, direction);
+            }
+        }
+        else {
+            await this.pushFrame(frame, direction);
+        }
+    }
+    /** Produce a frame to all consumers. */
+    async _produce(frame) {
+        for (const consumer of this._consumers) {
+            const newFrame = await this._transformer(frame);
+            await consumer.put(newFrame);
+        }
+    }
+}
+//# sourceMappingURL=producer_processor.js.map

package/dist/processors/text_transformer.d.ts

@@ -0,0 +1,30 @@
+/** Stateless text transformation processor for Pipecat. */
+import { type Frame } from "../frames/frames.ts";
+import { type FrameDirection, FrameProcessor } from "./frame_processor.ts";
+/** A text transformation, synchronous or asynchronous. */
+export type TextTransformFn = (text: string) => string | Promise<string>;
+/**
+ * Processor that applies transformation functions to text frames.
+ *
+ * This processor intercepts TextFrame objects and applies a user-provided
+ * transformation function to the text content. The function can be either
+ * synchronous or asynchronous.
+ */
+export declare class StatelessTextTransformer extends FrameProcessor {
+    protected _transformFn: TextTransformFn;
+    /**
+     * Initialize the text transformer.
+     *
+     * @param transformFn Function to apply to text content. Can be synchronous
+     *   (string -> string) or asynchronous (string -> Promise<string>).
+     */
+    constructor(transformFn: TextTransformFn);
+    /**
+     * Process frames, applying transformation to text frames.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=text_transformer.d.ts.map

package/dist/processors/text_transformer.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/text_transformer.py
+/** Stateless text transformation processor for Pipecat. */
+import { TextFrame } from "../frames/frames.js";
+import { FrameProcessor } from "./frame_processor.js";
+/**
+ * Processor that applies transformation functions to text frames.
+ *
+ * This processor intercepts TextFrame objects and applies a user-provided
+ * transformation function to the text content. The function can be either
+ * synchronous or asynchronous.
+ */
+export class StatelessTextTransformer extends FrameProcessor {
+    _transformFn;
+    /**
+     * Initialize the text transformer.
+     *
+     * @param transformFn Function to apply to text content. Can be synchronous
+     *   (string -> string) or asynchronous (string -> Promise<string>).
+     */
+    constructor(transformFn) {
+        super();
+        this._transformFn = transformFn;
+    }
+    /**
+     * Process frames, applying transformation to text frames.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (frame instanceof TextFrame) {
+            let result = this._transformFn(frame.text);
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            await this.pushFrame(new TextFrame({ text: result }));
+        }
+        else {
+            await this.pushFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=text_transformer.js.map

package/dist/registry/index.d.ts

@@ -0,0 +1,3 @@
+/** Worker registry for tracking known workers across runners. */
+export { WorkerRegistry } from "./registry.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/registry/__init__.py
+/** Worker registry for tracking known workers across runners. */
+export { WorkerRegistry } from "./registry.js";
+//# sourceMappingURL=index.js.map