@pipedog/core 0.0.0 → 0.2.0

package/dist/services/websocket_service.js

@@ -0,0 +1,654 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/websocket_service.py
+/**
+ * Base websocket service with automatic reconnection and error handling.
+ *
+ * Porting notes: upstream connects with the `websockets` library. Here the
+ * global `WebSocket` (Bun, Node ≥ 22, Deno, browsers) is wrapped in
+ * `WebsocketClientConnection`, which offers the subset of the `websockets`
+ * client API services use: `send()`, `recv()`, `async for`, `ping()`,
+ * `close()`, `state`, and the `ConnectionClosed` / `ConnectionClosedOK` /
+ * `ConnectionClosedError` exceptions. Awaiting `recv()` is a cancellation
+ * point, so cancelling a receive task stops it right away.
+ */
+import { CancelledError, monotonic, rethrowIfCancelled, sleep, suspend } from "@pipedog/asyncio";
+import { ErrorFrame } from "../frames/frames.js";
+import { logger } from "../utils/logger.js";
+import { defineMixin } from "../utils/mixin.js";
+import { exponentialBackoffTime, QuickFailureTracker } from "../utils/network.js";
+/**
+ * Default ceiling, in seconds, on the websocket closing handshake. Disconnect
+ * runs while a service handles the EndFrame, before the frame continues
+ * downstream, so an unacknowledged close delays pipeline shutdown by this
+ * much. The `websockets` default of 10s is long enough to be noticeable once
+ * several websocket services tear down in sequence.
+ */
+export const WS_CLOSE_TIMEOUT = 2.0;
+/** Default time, in seconds, to wait for the opening handshake (as `websockets`). */
+export const WS_OPEN_TIMEOUT = 10.0;
+//
+// Websocket client (stand-in for the `websockets` asyncio client).
+//
+/** Connection state, with the values of `websockets.protocol.State`. */
+export const State = {
+    CONNECTING: 0,
+    OPEN: 1,
+    CLOSING: 2,
+    CLOSED: 3,
+};
+/** Raised when reading from or writing to a closed connection. */
+export class ConnectionClosed extends Error {
+    name = "ConnectionClosed";
+    /** The close code, or null if no close frame was received. */
+    code;
+    /** The close reason. */
+    reason;
+    constructor(code, reason, message) {
+        super(message ?? (code === null ? "no close frame received or sent" : `${code} ${reason}`));
+        this.code = code;
+        this.reason = reason;
+    }
+}
+/** The connection was closed normally (close code 1000 or 1001). */
+export class ConnectionClosedOK extends ConnectionClosed {
+    name = "ConnectionClosedOK";
+}
+/** The connection was closed with an error (abnormal close code, or none). */
+export class ConnectionClosedError extends ConnectionClosed {
+    name = "ConnectionClosedError";
+}
+/**
+ * A websocket client connection with the asyncio-style API of the
+ * `websockets` library, over a standard `WebSocket`.
+ *
+ * Received messages are buffered until read with `recv()` or `for await`.
+ * Binary messages are returned as `Uint8Array`.
+ */
+export class WebsocketClientConnection {
+    #ws;
+    #messages = [];
+    #waiters = new Set();
+    #closed = null;
+    // The raw close code, as `websockets`' `close_code`: 1006 when no close
+    // frame was received, 1005 when one carried no code. The exception's
+    // `code` is null in both cases.
+    #closeCode = null;
+    #closedWaiters = new Set();
+    /** Maximum time, in seconds, to wait for the peer to acknowledge a close. */
+    closeTimeout;
+    constructor(ws, options = {}) {
+        this.#ws = ws;
+        this.closeTimeout =
+            options.closeTimeout === undefined ? WS_CLOSE_TIMEOUT : options.closeTimeout;
+        ws.binaryType = "arraybuffer";
+        ws.addEventListener("message", (event) => this.#onMessage(event.data));
+        ws.addEventListener("close", (event) => this.#onClose(event.code, event.reason));
+        if (ws.readyState === WebSocket.CLOSED)
+            this.#onClose(1006, "");
+    }
+    /** The underlying `WebSocket`. */
+    get webSocket() {
+        return this.#ws;
+    }
+    /** The connection state. */
+    get state() {
+        if (this.#closed)
+            return State.CLOSED;
+        return this.#ws.readyState;
+    }
+    /** The close code, once the connection is closed. */
+    get closeCode() {
+        return this.#closeCode;
+    }
+    /** The close reason, once the connection is closed. */
+    get closeReason() {
+        return this.#closed?.reason ?? null;
+    }
+    /**
+     * Send a text (string) or binary (bytes) message.
+     *
+     * @throws ConnectionClosed if the connection is closing or closed.
+     */
+    async send(message) {
+        if (this.#closed)
+            throw this.#closed;
+        if (this.#ws.readyState !== WebSocket.OPEN) {
+            throw new ConnectionClosedError(null, "", "websocket is not open");
+        }
+        this.#ws.send(message);
+    }
+    /**
+     * Receive the next message. A cancellation point.
+     *
+     * @throws ConnectionClosedOK / ConnectionClosedError once the connection
+     *   is closed and every buffered message has been read.
+     */
+    async recv() {
+        const message = this.#messages.shift();
+        if (message !== undefined)
+            return message;
+        if (this.#closed)
+            throw this.#closed;
+        let waiter;
+        return await suspend((resolve, reject) => {
+            waiter = { resolve, reject };
+            this.#waiters.add(waiter);
+            return () => {
+                if (waiter)
+                    this.#waiters.delete(waiter);
+            };
+        });
+    }
+    /**
+     * Iterate over incoming messages. Ends when the connection closes normally;
+     * throws `ConnectionClosedError` when it closes with an error.
+     */
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            try {
+                yield await this.recv();
+            }
+            catch (e) {
+                if (e instanceof ConnectionClosedOK)
+                    return;
+                throw e;
+            }
+        }
+    }
+    /**
+     * Check the connection is alive.
+     *
+     * The standard `WebSocket` API cannot send ping frames (runtimes answer the
+     * peer's pings themselves), so this only checks the connection is open.
+     *
+     * @throws ConnectionClosed if the connection is closing or closed.
+     */
+    async ping() {
+        if (this.#closed)
+            throw this.#closed;
+        if (this.#ws.readyState !== WebSocket.OPEN) {
+            throw new ConnectionClosedError(null, "", "websocket is not open");
+        }
+    }
+    /**
+     * Perform the closing handshake, waiting at most `closeTimeout` seconds for
+     * the peer to acknowledge it. Logs if the peer never acknowledged it, which
+     * keeps a teardown that silently cost `closeTimeout` from going unnoticed.
+     *
+     * @param code WebSocket close code.
+     * @param reason WebSocket close reason.
+     */
+    async close(code = 1000, reason = "") {
+        if (this.#closed)
+            return;
+        const start = monotonic();
+        try {
+            if (this.#ws.readyState === WebSocket.CONNECTING || this.#ws.readyState === WebSocket.OPEN) {
+                this.#ws.close(code, reason);
+            }
+            await this.#waitClosed(this.closeTimeout);
+        }
+        finally {
+            const elapsed = monotonic() - start;
+            if (!this.#closed) {
+                // The peer never acknowledged the close; drop the connection.
+                this.#onClose(1006, "");
+            }
+            if (this.closeTimeout !== null && elapsed >= this.closeTimeout) {
+                // Immediately follows the owning service's "Disconnecting from ..."
+                // log, so the connection needs no further identification.
+                logger.debug(`Peer did not acknowledge the websocket close within ${this.closeTimeout}s; connection dropped`);
+            }
+        }
+    }
+    async #waitClosed(timeout) {
+        if (this.#closed)
+            return;
+        let done;
+        await suspend((resolve) => {
+            done = () => resolve();
+            this.#closedWaiters.add(done);
+            const timer = timeout === null ? undefined : setTimeout(resolve, Math.max(0, timeout * 1000));
+            return () => {
+                if (timer)
+                    clearTimeout(timer);
+                if (done)
+                    this.#closedWaiters.delete(done);
+            };
+        }).finally(() => {
+            if (done)
+                this.#closedWaiters.delete(done);
+        });
+    }
+    #onMessage(data) {
+        let message;
+        if (typeof data === "string") {
+            message = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            message = new Uint8Array(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            message = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            message = String(data);
+        }
+        const waiter = this.#waiters.values().next().value;
+        if (waiter) {
+            this.#waiters.delete(waiter);
+            waiter.resolve(message);
+        }
+        else {
+            this.#messages.push(message);
+        }
+    }
+    #onClose(code, reason) {
+        if (this.#closed)
+            return;
+        this.#closeCode = code;
+        this.#closed =
+            code === 1000 || code === 1001
+                ? new ConnectionClosedOK(code, reason)
+                : new ConnectionClosedError(code === 1005 || code === 1006 ? null : code, reason);
+        const waiters = [...this.#waiters];
+        this.#waiters.clear();
+        for (const waiter of waiters)
+            waiter.reject(this.#closed);
+        const closedWaiters = [...this.#closedWaiters];
+        this.#closedWaiters.clear();
+        for (const done of closedWaiters)
+            done();
+    }
+}
+/**
+ * Open a websocket connection (`websockets.asyncio.client.connect`).
+ * Waiting for the opening handshake is a cancellation point; a cancelled or
+ * timed-out attempt closes the socket.
+ *
+ * @param uri The websocket URI to connect to.
+ * @returns The connected websocket.
+ */
+export async function websocketConnect(uri, options = {}) {
+    const init = {};
+    if (options.additionalHeaders)
+        init.headers = options.additionalHeaders;
+    if (options.subprotocols)
+        init.protocols = options.subprotocols;
+    let ws;
+    if (options.webSocketFactory) {
+        ws = await options.webSocketFactory(uri, init);
+    }
+    else if (init.headers) {
+        // Bun, Node (undici) and Deno accept an init object with headers.
+        const WebSocketWithInit = WebSocket;
+        ws = new WebSocketWithInit(uri, init);
+    }
+    else {
+        ws = new WebSocket(uri, init.protocols);
+    }
+    // Attach the listeners before the socket can deliver anything.
+    const connection = new WebsocketClientConnection(ws, { closeTimeout: options.closeTimeout });
+    const openTimeout = options.openTimeout === undefined ? WS_OPEN_TIMEOUT : options.openTimeout;
+    try {
+        await suspend((resolve, reject) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                resolve();
+                return () => { };
+            }
+            const onOpen = () => resolve();
+            const onError = () => reject(new Error(`websocket connection to ${uri} failed`));
+            const onClose = (event) => reject(new ConnectionClosedError(event.code, event.reason, `websocket connection to ${uri} closed during handshake (${event.code} ${event.reason})`));
+            ws.addEventListener("open", onOpen);
+            ws.addEventListener("error", onError);
+            ws.addEventListener("close", onClose);
+            const timer = openTimeout === null
+                ? undefined
+                : setTimeout(() => reject(new Error(`timed out during opening handshake with ${uri}`)), Math.max(0, openTimeout * 1000));
+            return () => {
+                if (timer)
+                    clearTimeout(timer);
+                ws.removeEventListener("open", onOpen);
+                ws.removeEventListener("error", onError);
+                ws.removeEventListener("close", onClose);
+            };
+        });
+    }
+    catch (e) {
+        try {
+            ws.close();
+        }
+        catch {
+            // The socket may not be closable yet; nothing else to release.
+        }
+        throw e;
+    }
+    return connection;
+}
+/**
+ * Base class for websocket-based services with automatic reconnection.
+ *
+ * Provides websocket connection management, automatic reconnection with
+ * exponential backoff, connection verification, and error handling.
+ * Subclasses implement service-specific connection and message handling
+ * logic (`_connectWebsocket()`, `_disconnectWebsocket()`, `_receiveMessages()`).
+ *
+ * Reconnection gives up in two ways, both leaving the service unusable: the
+ * provider rejects the configuration, which no amount of retrying will fix,
+ * or the attempts are exhausted. Errors are reported through a `reportError`
+ * callback, which takes the same optional `forceTreatAsPermanent` flag as
+ * `FrameProcessor.pushErrorFrame()`, so that giving up and saying so are the
+ * same act.
+ *
+ * A mixin: `class MyService(TTSService, WebsocketService)` upstream is
+ * `class MyService extends WebsocketService(TTSService)` here. Its options
+ * (`WebsocketServiceOptions`) are read from the constructor's options object.
+ */
+export const WebsocketService = defineMixin("WebsocketService", (Base) => {
+    class WebsocketServiceMixin extends Base {
+        _websocket = null;
+        _reconnectBackoffMinWait;
+        _reconnectBackoffMaxWait;
+        _reconnectOnError;
+        _wsCloseTimeout;
+        _reconnectInProgress = false;
+        _disconnecting = false;
+        // Rapid failure detection: when a server accepts the WebSocket handshake
+        // but immediately closes the connection (e.g. invalid API key, policy
+        // rejection), exponential backoff won't help because the handshake keeps
+        // succeeding. We detect this by tracking how long the connection
+        // survives after being established.
+        _quickFailureTracker = new QuickFailureTracker();
+        _lastConnectTime = 0.0;
+        constructor(...args) {
+            super(...args);
+            const options = (args[0] ?? {});
+            this._reconnectBackoffMinWait = options.reconnectBackoffMinWait ?? 4.0;
+            this._reconnectBackoffMaxWait = options.reconnectBackoffMaxWait ?? 10.0;
+            this._reconnectOnError = options.reconnectOnError ?? true;
+            this._wsCloseTimeout = options.wsCloseTimeout ?? WS_CLOSE_TIMEOUT;
+        }
+        /**
+         * Whether the service this is mixed into can still be given work.
+         *
+         * Always a `FrameProcessor` in practice, but this is a mixin and can't
+         * require it.
+         */
+        get _isServiceUsable() {
+            return this.isUsable ?? true;
+        }
+        /**
+         * Open a websocket connection with the service's close timeout applied.
+         *
+         * Wraps `websocketConnect()`, defaulting `closeTimeout` to
+         * `wsCloseTimeout`. Pass `closeTimeout` explicitly to override it for a
+         * service whose peer needs different closing behavior.
+         *
+         * @param uri The websocket URI to connect to.
+         * @param options Additional options passed to `websocketConnect()`.
+         * @returns The connected websocket.
+         */
+        async _websocketConnect(uri, options = {}) {
+            return await websocketConnect(uri, {
+                ...options,
+                closeTimeout: options.closeTimeout === undefined ? this._wsCloseTimeout : options.closeTimeout,
+            });
+        }
+        /**
+         * Verify the websocket connection is active and responsive.
+         *
+         * @returns True if connection is verified working, false otherwise.
+         */
+        async _verifyConnection() {
+            try {
+                if (!this._websocket || this._websocket.state === State.CLOSED) {
+                    return false;
+                }
+                await this._websocket.ping();
+                return true;
+            }
+            catch (e) {
+                rethrowIfCancelled(e);
+                logger.error(`${this} connection verification failed: ${errorText(e)}`);
+                return false;
+            }
+        }
+        /**
+         * Reconnect the websocket with the current attempt number.
+         *
+         * @param attemptNumber Current retry attempt number for logging.
+         * @returns True if reconnection and verification successful.
+         * @throws Error if the reconnected websocket fails verification.
+         */
+        async _reconnectWebsocket(attemptNumber) {
+            logger.warning(`${this} reconnecting (attempt: ${attemptNumber})`);
+            await this._disconnectWebsocket();
+            await this._connectWebsocket();
+            if (!(await this._verifyConnection())) {
+                throw new Error(`${this} websocket reconnection failed verification`);
+            }
+            return true;
+        }
+        async _tryReconnect(options = {}) {
+            const maxRetries = options.maxRetries ?? 3;
+            const reportError = options.reportError ?? null;
+            // Prevent concurrent reconnection attempts
+            if (this._reconnectInProgress) {
+                logger.warning(`${this} reconnect attempt aborted: already in progress`);
+                return false;
+            }
+            // Reconnecting can't fix whatever made the service unusable.
+            if (!this._isServiceUsable) {
+                logger.error(`${this} not reconnecting: the service is no longer usable`);
+                return false;
+            }
+            this._reconnectInProgress = true;
+            let lastException = null;
+            try {
+                for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                    try {
+                        logger.warning(`${this} reconnecting, attempt ${attempt}`);
+                        if (await this._reconnectWebsocket(attempt)) {
+                            logger.info(`${this} reconnected successfully on attempt ${attempt}`);
+                            this._lastConnectTime = monotonic();
+                            return true;
+                        }
+                    }
+                    catch (e) {
+                        rethrowIfCancelled(e);
+                        lastException = e;
+                        logger.error(`${this} reconnection attempt ${attempt} failed: ${errorText(e)}`);
+                        if (reportError) {
+                            await reportError(new ErrorFrame({
+                                error: `${this} reconnection attempt ${attempt} failed: ${errorText(e)}`,
+                                exception: e,
+                            }));
+                        }
+                    }
+                    // A rejected attempt may have been rejected for a reason reporting
+                    // it identified as terminal.
+                    if (!this._isServiceUsable) {
+                        logger.error(`${this} abandoning reconnection: the service is no longer usable`);
+                        return false;
+                    }
+                    const waitTime = exponentialBackoffTime(attempt, this._reconnectBackoffMinWait, this._reconnectBackoffMaxWait);
+                    await sleep(waitTime);
+                }
+                let msg = `${this} failed to reconnect after ${maxRetries} attempts`;
+                if (lastException) {
+                    msg += `: ${errorText(lastException)}`;
+                }
+                logger.error(msg);
+                if (reportError) {
+                    await reportError(new ErrorFrame({ error: msg, exception: lastException }), {
+                        forceTreatAsPermanent: true,
+                    });
+                }
+                return false;
+            }
+            finally {
+                this._reconnectInProgress = false;
+            }
+        }
+        /** Attempt to send a message, retrying after reconnect if necessary. */
+        async sendWithRetry(message, reportError) {
+            try {
+                // If websocket isn't connected/present, treat as a send failure — the
+                // broad catch below will trigger a reconnect attempt.
+                if (this._websocket === null) {
+                    throw new Error(`${this} no websocket connected`);
+                }
+                await this._websocket.send(message);
+            }
+            catch (e) {
+                rethrowIfCancelled(e);
+                logger.error(`${this} send failed: ${errorText(e)}, will try to reconnect`);
+                // Try to reconnect before retrying
+                const success = await this._tryReconnect({ reportError });
+                if (success && this._websocket !== null) {
+                    logger.info(`${this} reconnected successfully, will retry send the message`);
+                    // trying to send the message one more time
+                    await this._websocket.send(message);
+                }
+                else {
+                    logger.error(`${this} send failed; unable to reconnect`);
+                }
+            }
+        }
+        /**
+         * Check if reconnection should be attempted and try if appropriate.
+         *
+         * @param errorMessage Human-readable error message for logging.
+         * @param reportError Callback function to report connection errors.
+         * @param error The error that occurred (may be null for graceful closes).
+         * @returns True if should continue the receive loop, false if should break.
+         */
+        async _maybeTryReconnect(errorMessage, reportError, error = null) {
+            // Don't reconnect if we're intentionally disconnecting
+            if (this._disconnecting) {
+                if (error) {
+                    logger.warning(`${this} error during disconnect: ${errorText(error)}`);
+                }
+                else {
+                    logger.debug(`${this} receive loop ended during disconnect`);
+                }
+                return false;
+            }
+            // Check if the connection died too quickly after being established.
+            // This catches cases where the handshake succeeds but the server
+            // immediately closes (e.g. invalid API key). Exponential backoff won't
+            // help here because the handshake keeps succeeding — we need to stop
+            // the loop.
+            if (this._lastConnectTime > 0) {
+                const connectionDuration = monotonic() - this._lastConnectTime;
+                const result = this._quickFailureTracker.record(connectionDuration);
+                if (result.isQuickFailure) {
+                    logger.warning(`${this} connection lasted only ${connectionDuration.toFixed(1)}s ` +
+                        `(${this._quickFailureTracker.count}/` +
+                        `${this._quickFailureTracker.maxConsecutiveFailures} ` +
+                        "consecutive quick failures)");
+                }
+                if (result.shouldGiveUp) {
+                    const msg = `${this} connection failed ` +
+                        `${this._quickFailureTracker.maxConsecutiveFailures} ` +
+                        "times immediately after connecting";
+                    logger.error(msg);
+                    await reportError(new ErrorFrame({ error: msg }), { forceTreatAsPermanent: true });
+                    return false;
+                }
+            }
+            // Log the message
+            logger.warning(errorMessage);
+            // Try to reconnect if enabled
+            if (this._reconnectOnError) {
+                return await this._tryReconnect({ reportError });
+            }
+            // `reconnectOnError` governs this loop only: services that turn it off
+            // reconnect on demand in `sendWithRetry` instead. Reporting the drop as
+            // terminal would close that path too.
+            await reportError(new ErrorFrame({ error: errorMessage, exception: error }));
+            return false;
+        }
+        /**
+         * Handle websocket message receiving with automatic retry logic.
+         *
+         * Continuously receives messages with automatic reconnection on errors.
+         * Uses exponential backoff between retry attempts and reports fatal
+         * errors after maximum retries are exhausted.
+         *
+         * @param reportError Callback function to report connection errors.
+         */
+        async _receiveTaskHandler(reportError) {
+            while (true) {
+                this._lastConnectTime = monotonic();
+                try {
+                    await this._receiveMessages();
+                    // _receiveMessages() returned normally. This happens when the
+                    // websocket closes gracefully (server sent close frame). The
+                    // `for await` loop over the websocket exits without throwing in
+                    // this case. We must handle this to avoid an infinite loop.
+                    const message = `${this} connection closed by server`;
+                    const shouldContinue = await this._maybeTryReconnect(message, reportError);
+                    if (!shouldContinue)
+                        break;
+                }
+                catch (e) {
+                    if (e instanceof CancelledError)
+                        throw e;
+                    if (e instanceof ConnectionClosedOK) {
+                        // Normal closure, don't retry
+                        logger.debug(`${this} connection closed normally: ${e.message}`);
+                        break;
+                    }
+                    let message;
+                    if (e instanceof ConnectionClosedError) {
+                        // Connection closed with error (e.g., no close frame
+                        // received/sent). This often indicates network issues, server
+                        // problems, or abrupt disconnection.
+                        message = `${this} connection closed, but with an error: ${e.message}`;
+                    }
+                    else {
+                        // General error during message receiving
+                        message = `${this} error receiving messages: ${errorText(e)}`;
+                    }
+                    const shouldContinue = await this._maybeTryReconnect(message, reportError, e);
+                    if (!shouldContinue)
+                        break;
+                }
+            }
+        }
+        /**
+         * Connect to the service and reset the disconnecting flag.
+         *
+         * Manages the disconnecting flag to enable reconnection. Subclasses
+         * should call `super._connect()` first, then implement their specific
+         * connection logic including websocket connection via
+         * `_connectWebsocket()` and any additional setup required.
+         */
+        async _connect() {
+            this._disconnecting = false;
+            this._quickFailureTracker.reset();
+        }
+        /**
+         * Disconnect from the service and set the disconnecting flag.
+         *
+         * Manages the disconnecting flag to prevent reconnection during
+         * intentional disconnect. Subclasses should call `super._disconnect()`
+         * first, then implement their specific disconnection logic including
+         * websocket disconnection via `_disconnectWebsocket()` and any cleanup
+         * required.
+         */
+        async _disconnect() {
+            this._disconnecting = true;
+        }
+    }
+    return WebsocketServiceMixin;
+});
+/** Python's `f"{e}"` for an exception. */
+function errorText(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+//# sourceMappingURL=websocket_service.js.map

package/dist/services/whisper/index.d.ts

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

package/dist/services/whisper/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/whisper/__init__.py
+// Upstream's __init__.py is empty: it only marks the package. The provider
+// modules themselves live in their own packages (see porting/manifest.json).
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/xai/index.d.ts

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

package/dist/services/xai/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/xai/__init__.py
+// Upstream's __init__.py is empty: it only marks the package. The provider
+// modules themselves live in their own packages (see porting/manifest.json).
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/xtts/index.d.ts

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